// Copyright (c) 2005-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:

//

// INCLUDE FILES

#include "TestContentHandler.h"

#include "XMLOutputContentHandler.h"

#include "xmlengtester.h"

#include <e32svr.h>

#include <e32math.h>

#include <f32file.h>

#include "xmlengtesterdef.h"

#include <Xml\Parser.h>

#include <Xml\ParserFeature.h>

#include <libc\string.h>

#include <charconv.h>

#include <UTF.H>

using namespace Xml;

// -----------------------------------------------------------------------------

// CLibxml2Tester::Delete

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

// Called from destructor. 

// -----------------------------------------------------------------------------

//

void CLibxml2Tester::Delete() 

    {

    }

// -----------------------------------------------------------------------------

// CLibxml2Tester::RunMethodL

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

// -----------------------------------------------------------------------------

//

TInt CLibxml2Tester::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

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

        // Second is the actual implementation member function.

        // test

        ENTRY( "CompareFiles", CLibxml2Tester::CompareFilesL ),        

        // sax

        ENTRY( "SAXParseFile", CLibxml2Tester::ParseFileSAXL ),

        ENTRY( "SAXParseBuffer", CLibxml2Tester::ParseBufSAXL ),

        ENTRY( "SAXParseFileWithNameSpaceMapping", CLibxml2Tester::ParseFileSAXNSL ),

        ENTRY( "SAXParseFileWithTagToLowerCase", CLibxml2Tester::ParseFileSAXLowerCaseL ),

        ENTRY( "SAXParseFileWithExternalSubsetFeature", CLibxml2Tester::ParseFileSAXExternalSubsetL ),

        // dom       

        ENTRY( "ParseFile", CLibxml2Tester::ParseFileDomL ),

        ENTRY( "SaveXmlToFile", CLibxml2Tester::SaveXmlToFileDomL ),

        ENTRY( "CheckOuterXml", CLibxml2Tester::CheckOuterXmlL ),

        ENTRY( "CheckInnerXml", CLibxml2Tester::CheckInnerXmlL ),

        ENTRY( "CreateDocument", CLibxml2Tester::CreateDocumentL ),

        ENTRY( "CheckDocumentParameters", CLibxml2Tester::CheckDocumentParametersL ),

        ENTRY( "CreateDocumentElement", CLibxml2Tester::CreateDocumentElementL ),

        ENTRY( "CreateDocumentFromNode", CLibxml2Tester::CreateDocumentFromNodeL ),

        ENTRY( "SaveXmlToUTF16LE", CLibxml2Tester::SaveXmlToBufferUTF16L ),

        ENTRY( "TestNodeFilter1", CLibxml2Tester::TestNodeFilterL ),

        ENTRY( "CloneDocument", CLibxml2Tester::CloneDocumentL ),       

        ENTRY( "CheckNotNullElement", CLibxml2Tester::CheckNotNullElementL ),

        ENTRY( "CheckSiblingFunctions", CLibxml2Tester::CheckSiblingFunctionsL ),

        ENTRY( "CheckNodeParameters", CLibxml2Tester::CheckNodeParametersL ),

        ENTRY( "ParentNodes", CLibxml2Tester::ParentNodesL ),

        //ENTRY( "NameModification", CLibxml2Tester::NameModificationL ),

        ENTRY( "CheckNamespaces", CLibxml2Tester::CheckNamespacesL ),       

        ENTRY( "CheckProcessingInstruction", CLibxml2Tester::CheckProcessingInstructionL ),

        ENTRY( "CheckComments", CLibxml2Tester::CheckCommentsL ),       

        ENTRY( "CheckCDATA", CLibxml2Tester::CheckCDATAL ),

        ENTRY( "CheckTextNode", CLibxml2Tester::CheckTextNodeL ),

        //ENTRY( "CheckDocumentFragment", CLibxml2Tester::CheckDocumentFragmentL ),

        ENTRY( "NodeNamespacePocessing", CLibxml2Tester::NodeNamespacePocessingL ),       

        ENTRY( "CheckEntityRef", CLibxml2Tester::CheckEntityRefL ),

        ENTRY( "NodeTreeModification", CLibxml2Tester::NodeTreeModificationL ),       

        ENTRY( "NodeTreeDeleting", CLibxml2Tester::NodeTreeDeletingL ),

        ENTRY( "CheckNodeList", CLibxml2Tester::CheckNodeListL ),       

        ENTRY( "ElementNamespacePocessing", CLibxml2Tester::ElementNamespacePocessingL ),

        ENTRY( "CheckAttributes", CLibxml2Tester::CheckAttributesL ),       

        ENTRY( "CheckElementAttributes", CLibxml2Tester::CheckElementAttributesL ),

        ENTRY( "CheckModifAttributes", CLibxml2Tester::CheckModifAttributesL ),       

        ENTRY( "AddingAttributes", CLibxml2Tester::AddingAttributesL ),

        ENTRY( "AddingElements", CLibxml2Tester::AddingElementsL ),  

        ENTRY( "CheckModifElement", CLibxml2Tester::CheckModifElementL ), 

        ENTRY( "SetElementText", CLibxml2Tester::SetElementTextL ),   

        ENTRY( "WHAT", CLibxml2Tester::CheckNextL ),  

        ENTRY( "AddXmlId", CLibxml2Tester::AddXmlIdL ),

        ENTRY( "FindXmlId", CLibxml2Tester::FindXmlIdL ),

        ENTRY( "SetTextNoEncTest", CLibxml2Tester::SetTextNoEncTestL),

        ENTRY( "AppendTextNoEncTest", CLibxml2Tester::AppendTextNoEncTestL),

        ENTRY( "SetValueNoEncTest", CLibxml2Tester::SetValueNoEncTestL),

        ENTRY( "CreateDocument2", CLibxml2Tester::CreateDocument2L),

        ENTRY( "CreateEntityReferenceTest", CLibxml2Tester::CreateEntityReferenceTestL),

        ENTRY( "ParseFileDom2", CLibxml2Tester::ParseFileDom2L),

        ENTRY( "ParseFileDom3", CLibxml2Tester::ParseFileDom3L),

        ENTRY( "LookupNamespaceByPrefixTest", CLibxml2Tester::LookupNamespaceByPrefixTestL),

        ENTRY( "LookupNamespaceByUriTest", CLibxml2Tester::LookupNamespaceByUriTestL),

        ENTRY( "LookupNamespaceByPrefixTest2", CLibxml2Tester::LookupNamespaceByPrefixTest2L),

        ENTRY( "LookupNamespaceByUriTest2", CLibxml2Tester::LookupNamespaceByUriTest2L),

        ENTRY( "RemoveChildrenTest", CLibxml2Tester::RemoveChildrenTestL),

        ENTRY( "UserDataTest", CLibxml2Tester::UserDataTestL),

        ENTRY( "BaseUriTest", CLibxml2Tester::BaseUriTestL),

        ENTRY( "AddXmlIdTest", CLibxml2Tester::AddXmlIdTestL),

        ENTRY( "AddXmlId2", CLibxml2Tester::AddXmlId2L),

        ENTRY( "AddXmlId3", CLibxml2Tester::AddXmlId3L),

        //chunkparser

        ENTRY( "ParseFileChunk", CLibxml2Tester::ParseFileChunkL ),

        //chunkcontainer    

        ENTRY("ChunkContainerGetList",CLibxml2Tester::ChunkContainer_GetListL),

        ENTRY("ChunkContainerCid",CLibxml2Tester::ChunkContainer_CidL),

        ENTRY("ChunkContainerCidError",CLibxml2Tester::ChunkContainer_CidErrorL),

        ENTRY("ChunkContainerChunk",CLibxml2Tester::ChunkContainer_ChunkL),

        ENTRY("ChunkContainerOffset",CLibxml2Tester::ChunkContainer_OffsetL),

        ENTRY("ChunkContainerSize",CLibxml2Tester::ChunkContainer_SizeL),

        ENTRY("ChunkContainerNodeType",CLibxml2Tester::ChunkContainer_NodeTypeL),

        ENTRY("ChunkContainerRemove",CLibxml2Tester::ChunkContainer_RemoveL),

        ENTRY("ChunkContainerRemove2",CLibxml2Tester::ChunkContainer_Remove2L),

        ENTRY("ChunkContainerRemove3",CLibxml2Tester::ChunkContainer_Remove3L),

        ENTRY("ChunkContainerUnlink",CLibxml2Tester::ChunkContainer_UnlinkL),

        ENTRY("ChunkContainerReplaceWith",CLibxml2Tester::ChunkContainer_ReplaceWithL),

        ENTRY("ChunkContainerSubstituteFor",CLibxml2Tester::ChunkContainer_SubstituteForL),

        ENTRY("ChunkContainerCopy",CLibxml2Tester::ChunkContainer_CopyL),

        ENTRY("ChunkContainerCopy2",CLibxml2Tester::ChunkContainer_Copy2L),  

        ENTRY("ChunkContainerCopy3",CLibxml2Tester::ChunkContainer_Copy3L),       

        ENTRY("ChunkContainerCopy4",CLibxml2Tester::ChunkContainer_Copy4L),   

        ENTRY("ChunkContainerCopyTo",CLibxml2Tester::ChunkContainer_CopyToL),       

        ENTRY("ChunkContainerClone",CLibxml2Tester::ChunkContainer_CloneL),

        ENTRY("ChunkContainerAdoptNode",CLibxml2Tester::ChunkContainer_AdoptNodeL),        

        ENTRY("ChunkContainerSetAsFirstSibling",CLibxml2Tester::ChunkContainer_SetAsFirstSiblingL),

        ENTRY("ChunkContainerSetAsLastSibling",CLibxml2Tester::ChunkContainer_SetAsLastSiblingL),

        ENTRY("ChunkContainerMoveBeforeSibling",CLibxml2Tester::ChunkContainer_MoveBeforeSiblingL),

        ENTRY("ChunkContainerMoveAfterSibling",CLibxml2Tester::ChunkContainer_MoveAfterSiblingL),

        ENTRY("ChunkContainerMoveTo",CLibxml2Tester::ChunkContainer_MoveToL),

        ENTRY("ChunkContainerReconcileNamespaces",CLibxml2Tester::ChunkContainer_ReconcileNamespacesL),

        //filecontainer     

        ENTRY("FileContainerGetList",CLibxml2Tester::FileContainer_GetListL),

        ENTRY("FileContainerCid",CLibxml2Tester::FileContainer_CidL),

        ENTRY("FileContainerCidError",CLibxml2Tester::FileContainer_CidErrorL),

        ENTRY("FileContainerSize",CLibxml2Tester::FileContainer_SizeL),

        ENTRY("FileContainerFile",CLibxml2Tester::FileContainer_FileL),

        ENTRY("FileContainerNodeType",CLibxml2Tester::FileContainer_NodeTypeL),

        ENTRY("FileContainerRemove",CLibxml2Tester::FileContainer_RemoveL),

        ENTRY("FileContainerRemove2",CLibxml2Tester::FileContainer_Remove2L),

        ENTRY("FileContainerRemove3",CLibxml2Tester::FileContainer_Remove3L),

        ENTRY("FileContainerUnlink",CLibxml2Tester::FileContainer_UnlinkL),

        ENTRY("FileContainerReplaceWith",CLibxml2Tester::FileContainer_ReplaceWithL),

        ENTRY("FileContainerSubstituteFor",CLibxml2Tester::FileContainer_SubstituteForL),

        ENTRY("FileContainerCopy",CLibxml2Tester::FileContainer_CopyL),

        ENTRY("FileContainerCopy2",CLibxml2Tester::FileContainer_Copy2L),  

        ENTRY("FileContainerCopy3",CLibxml2Tester::FileContainer_Copy3L),       

        ENTRY("FileContainerCopy4",CLibxml2Tester::FileContainer_Copy4L),   

        ENTRY("FileContainerCopyTo",CLibxml2Tester::FileContainer_CopyToL),       

        ENTRY("FileContainerClone",CLibxml2Tester::FileContainer_CloneL),

        ENTRY("FileContainerAdoptNode",CLibxml2Tester::FileContainer_AdoptNodeL),        

        ENTRY("FileContainerSetAsFirstSibling",CLibxml2Tester::FileContainer_SetAsFirstSiblingL),

        ENTRY("FileContainerSetAsLastSibling",CLibxml2Tester::FileContainer_SetAsLastSiblingL),

        ENTRY("FileContainerMoveBeforeSibling",CLibxml2Tester::FileContainer_MoveBeforeSiblingL),

        ENTRY("FileContainerMoveAfterSibling",CLibxml2Tester::FileContainer_MoveAfterSiblingL),

        ENTRY("FileContainerMoveTo",CLibxml2Tester::FileContainer_MoveToL),

        ENTRY("FileContainerReconcileNamespaces",CLibxml2Tester::FileContainer_ReconcileNamespacesL),

        // Binary Container

        ENTRY( "BinaryContainer", CLibxml2Tester::BinaryContainerL),

        ENTRY( "PartialBinaryContainer", CLibxml2Tester::PartialBinaryContainerL ),

        ENTRY( "TestAppendContents", CLibxml2Tester::TestAppendContentsL),

        ENTRY("BinaryContainerGetList",CLibxml2Tester::BinaryContainer_GetListL),

        ENTRY("BinaryContainerGetList2",CLibxml2Tester::BinaryContainer_GetList2L),

        ENTRY("BinaryContainerCidError",CLibxml2Tester::BinaryContainer_CidErrorL),

        ENTRY("BinaryContainerRemove",CLibxml2Tester::BinaryContainer_RemoveL),

        ENTRY("BinaryContainerRemove2",CLibxml2Tester::BinaryContainer_Remove2L),

        ENTRY("BinaryContainerRemove3",CLibxml2Tester::BinaryContainer_Remove3L),

        ENTRY("BinaryContainerUnlink",CLibxml2Tester::BinaryContainer_UnlinkL),

        ENTRY("BinaryContainerReplaceWith",CLibxml2Tester::BinaryContainer_ReplaceWithL),

        ENTRY("BinaryContainerSubstituteFor",CLibxml2Tester::BinaryContainer_SubstituteForL),

        ENTRY("BinaryContainerCopy",CLibxml2Tester::BinaryContainer_CopyL),

        ENTRY("BinaryContainerCopy2",CLibxml2Tester::BinaryContainer_Copy2L),  

        ENTRY("BinaryContainerCopy3",CLibxml2Tester::BinaryContainer_Copy3L),       

        ENTRY("BinaryContainerCopy4",CLibxml2Tester::BinaryContainer_Copy4L),   

        ENTRY("BinaryContainerCopyTo",CLibxml2Tester::BinaryContainer_CopyToL),       

        ENTRY("BinaryContainerClone",CLibxml2Tester::BinaryContainer_CloneL),

        ENTRY("BinaryContainerAdoptNode",CLibxml2Tester::BinaryContainer_AdoptNodeL),        

        ENTRY("BinaryContainerSetAsFirstSibling",CLibxml2Tester::BinaryContainer_SetAsFirstSiblingL),

        ENTRY("BinaryContainerSetAsLastSibling",CLibxml2Tester::BinaryContainer_SetAsLastSiblingL),

        ENTRY("BinaryContainerMoveBeforeSibling",CLibxml2Tester::BinaryContainer_MoveBeforeSiblingL),

        ENTRY("BinaryContainerMoveAfterSibling",CLibxml2Tester::BinaryContainer_MoveAfterSiblingL),

        ENTRY("BinaryContainerMoveTo",CLibxml2Tester::BinaryContainer_MoveToL),

        ENTRY("BinaryContainerReconcileNamespaces",CLibxml2Tester::BinaryContainer_ReconcileNamespacesL),

        // XPath

        ENTRY( "Evaluate", CLibxml2Tester::EvaluateExpressionL ),   

        ENTRY( "SaveResult", CLibxml2Tester::SaveResultL ), 

        ENTRY( "ToNumber", CLibxml2Tester::ToNumberL ), 

        ENTRY( "ToBool", CLibxml2Tester::ToBoolL ),

        ENTRY( "ToString", CLibxml2Tester::ToStringL ),

        ENTRY( "Instances", CLibxml2Tester::InstanceL ),

        ENTRY( "ExtVector", CLibxml2Tester::ExtensionVectorL ),

        ENTRY( "ExtFunction", CLibxml2Tester::ExtensionFunctionL ),

        // Utils       

        ENTRY( "EscapeForXmlValue", CLibxml2Tester::UtilsEscapeForXmlValueL ),

        ENTRY( "XmlCharFromDes", CLibxml2Tester::UtilsXmlCharFromDesL ),

        ENTRY( "XmlCharFromDes8", CLibxml2Tester::UtilsXmlCharFromDes8L ),

        // Serialize Default

        ENTRY( "SerializeDefaultFile", CLibxml2Tester::SerializeDefaultFileL),

        // Serialize XOP

        ENTRY( "SerializeXOP", CLibxml2Tester::SerializeXOPL),

        ENTRY( "DirtySerializeXOP", CLibxml2Tester::DirtySerializeXOPL),

        ENTRY( "SerializeXopSoap", CLibxml2Tester::SerializeXopSoapL),

        ENTRY( "MultiSerializeXopSoap", CLibxml2Tester::MultiSerializeXopSoapL),

        ENTRY( "SerializeXopFile", CLibxml2Tester::SerializeXopFileL),

        ENTRY( "SerializeXopFileDirty", CLibxml2Tester::SerializeXopFileDirtyL),

        ENTRY( "SerializeXopDirtySoap", CLibxml2Tester::SerializeXopDirtySoapL),

        ENTRY( "SerializeXopBuffer", CLibxml2Tester::SerializeXopBufferL),

        ENTRY( "Serxop3diffCont", CLibxml2Tester::Serxop3diffContL),

        //Serialize GZIP

        ENTRY( "SerializeGZIP", CLibxml2Tester::SerializeGZIPL),

        ENTRY( "DecompressGZIP", CLibxml2Tester::DecompressGZIPL),

        ENTRY( "DecompressBufferGZIP", CLibxml2Tester::DecompressBufferGZIPL),

        ENTRY( "CompressBufferGZIP", CLibxml2Tester::CompressBufferGZIPL),

        ENTRY( "SerializeDirtyGzip", CLibxml2Tester::SerializeDirtyGzipL),

        //Serializer

        ENTRY( "TestSerializer", CLibxml2Tester::TestSerializerL),

        ENTRY( "TestSetOutputBuffer", CLibxml2Tester::TestSetOutputBufferL),

        ENTRY( "TestSetOutputFile", CLibxml2Tester::TestSetOutputFileL),

        ENTRY( "TestSetOutputStream", CLibxml2Tester::TestSetOutputStreamL),

        ENTRY( "TestSerializationOptions", CLibxml2Tester::TestSerializationOptionsL),

        ENTRY( "TestSerializeFile1", CLibxml2Tester::TestSerializeFile1L),

        ENTRY( "TestSerializeFile2", CLibxml2Tester::TestSerializeFile2L),

        ENTRY( "TestSerializeFile3", CLibxml2Tester::TestSerializeFile3L),

        ENTRY( "TestSerializeBuffer", CLibxml2Tester::TestSerializeBufferL),

        ENTRY( "TestSerializePartTree", CLibxml2Tester::TestSerializePartTreeL),

        ENTRY( "TestSerializeFileBuffer", CLibxml2Tester::TestSerializeFileBufferL),

        ENTRY( "TestSerializeChilds", CLibxml2Tester::TestSerializeChildsL),

        ENTRY( "TestSerializeFileConvinience", CLibxml2Tester::TestSerializeFileConvinienceL),

        ENTRY( "TestSerializeBufferConvinience", CLibxml2Tester::TestSerializeBufferConvinienceL),

        ENTRY( "TestMultipleSerializeToBuffer", CLibxml2Tester::TestMultipleSerializeToBufferL),

        ENTRY( "TestSerializationOptionsBuffer", CLibxml2Tester::TestSerializationOptionsBufferL),

        ENTRY( "TestContentType", CLibxml2Tester::TestContentTypeL),

        //Deserialize

        ENTRY( "Deserialize", CLibxml2Tester::DeserializeL),

        ENTRY( "Deserialize2", CLibxml2Tester::Deserialize2L),

        ENTRY( "DeserializeFromFile", CLibxml2Tester::DeserializeFromFileL),

        ENTRY( "DeserializeFromBuffer", CLibxml2Tester::DeserializeFromBufferL),

        ENTRY( "TestDeserializer", CLibxml2Tester::TestDeserializerL),

        ENTRY( "TestSetInputFile", CLibxml2Tester::TestSetInputFileL),

        ENTRY( "TestSetInputBuffer", CLibxml2Tester::TestSetInputBufferL),

        ENTRY( "TestSetContentHandler", CLibxml2Tester::TestSetContentHandlerL),

        ENTRY( "TestEnableFeature", CLibxml2Tester::TestEnableFeatureL),

        ENTRY( "TestDisableFeature", CLibxml2Tester::TestDisableFeatureL),

        ENTRY( "TestIsFeatureEnabled", CLibxml2Tester::TestIsFeatureEnabledL),

        ENTRY( "TestUseExternalData", CLibxml2Tester::TestUseExternalDataL),

        ENTRY( "TestExternalData", CLibxml2Tester::TestExternalDataL),

        ENTRY( "TestDesFileConvinience", CLibxml2Tester::TestDesFileConvinienceL),

        ENTRY( "TestDesBufferConvinience", CLibxml2Tester::TestDesBufferConvinienceL),

        ENTRY( "TestDeserializerBuffer", CLibxml2Tester::TestDeserializerBufferL),

        ENTRY( "TestSetParsingOptions1", CLibxml2Tester::TestSetParsingOptions1L),

        ENTRY( "DeserializeInfoset", CLibxml2Tester::DeserializeInfosetL),

        ENTRY( "Deserialize2Infoset", CLibxml2Tester::Deserialize2InfosetL),

        ENTRY( "DeserializeFromFileInfoset", CLibxml2Tester::DeserializeFromFileInfosetL),

        ENTRY( "DeserializeFromBufferInfoset", CLibxml2Tester::DeserializeFromBufferInfosetL),

        ENTRY( "TestDeserializerInfoset", CLibxml2Tester::TestDeserializerInfosetL),

        ENTRY( "TestSetInputFileInfoset", CLibxml2Tester::TestSetInputFileInfosetL),

        ENTRY( "TestSetInputBufferInfoset", CLibxml2Tester::TestSetInputBufferInfosetL),

        ENTRY( "TestSetContentHandlerInfoset", CLibxml2Tester::TestSetContentHandlerInfosetL),

        ENTRY( "TestEnableFeatureInfoset", CLibxml2Tester::TestEnableFeatureInfosetL),

        ENTRY( "TestDisableFeatureInfoset", CLibxml2Tester::TestDisableFeatureInfosetL),

        ENTRY( "TestIsFeatureEnabledInfoset", CLibxml2Tester::TestIsFeatureEnabledInfosetL),

        ENTRY( "TestUseExternalDataInfoset", CLibxml2Tester::TestUseExternalDataInfosetL),

        ENTRY( "TestExternalDataInfoset", CLibxml2Tester::TestExternalDataInfosetL),

        ENTRY( "TestDesFileConvinienceInfoset", CLibxml2Tester::TestDesFileConvinienceInfosetL),

        ENTRY( "TestDesBufferConvinienceInfoset", CLibxml2Tester::TestDesBufferConvinienceInfosetL),

        ENTRY( "TestDeserializerBufferInfoset", CLibxml2Tester::TestDeserializerBufferInfosetL),

        //DOMDeserialize

        ENTRY( "DOMDeserialize", CLibxml2Tester::DOMDeserializeL),

        ENTRY( "DOMDeserialize2", CLibxml2Tester::DOMDeserialize2L),

        ENTRY( "DOMDeserializeFromFile", CLibxml2Tester::DOMDeserializeFromFileL),

        ENTRY( "DOMDeserializeFromFile2", CLibxml2Tester::DOMDeserializeFromFile2L),

        ENTRY( "DOMDeserializeFromBuffer", CLibxml2Tester::DOMDeserializeFromBufferL),

        ENTRY( "TestDOMDeserializer", CLibxml2Tester::TestDOMDeserializerL),

        ENTRY( "TestDOMSetInputFile", CLibxml2Tester::TestDOMSetInputFileL),

        ENTRY( "TestDOMSetInputBuffer", CLibxml2Tester::TestDOMSetInputBufferL),

        ENTRY( "TestDOMUseExternalData", CLibxml2Tester::TestDOMUseExternalDataL),

        ENTRY( "TestDOMExternalData", CLibxml2Tester::TestDOMExternalDataL)

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

/******************************  TEST  **************************************/    

TBool CLibxml2Tester::CompareDescAndChar(const char* aString,TDesC8& aDesc)

{

	TInt strLen = strlen(aString);

	TInt desLen = aDesc.Length();

	if (strLen != desLen)

	{

		return FALSE;	

	}

	else

	{

		for(TInt i = 0; i < strLen; i++)

		{

			if (aString[i] != aDesc[i])

				return FALSE;

		}

	}	

	return TRUE;

}

TBool CLibxml2Tester::CompareDescAndChar(const TUint8* aString,TDesC8& aDesc)

{

	TInt strLen = strlen((char*)aString);

	TInt desLen = aDesc.Length();

	if (strLen != desLen)

	{

		return FALSE;	

	}

	else

	{

		for(TInt i = 0; i < strLen; i++)

		{

			if (aString[i] != aDesc[i])

				return FALSE;

		}

	}	

	return TRUE;

}

void CLibxml2Tester::SaveNode(RFile aFile,TXmlEngNode aNode)

	{

	_LIT8(KInfoOnStartEle,"Element: %S \r\n");

	_LIT8(KInfoOnAttribute,"\tAttribute \tname: %S \t value: %S \r\n");

	_LIT8(KInfoOnAttribute2,"Attribute \tname: %S \t value: %S \r\n");

	_LIT8(KInfoOnText,"Text: %S\r\n");

	TBuf8<256> info;

	if(aNode.NodeType() == TXmlEngNode::EElement)

		{

		TPtrC8 wsk = aNode.Name();

		info.Format(KInfoOnStartEle,&wsk);	

		aFile.Write(info);

		RXmlEngNodeList <TXmlEngAttr> array;

		if(aNode.HasAttributes())

			{

			aNode.AsElement().GetAttributes(array);

			while(array.HasNext())

				{

				TXmlEngAttr attr = array.Next();

				TPtrC8 wsk1 = attr.Name();

				TPtrC8 wsk2 = attr.Value();

				info.Format(KInfoOnAttribute,&wsk1,&wsk2);

				aFile.Write(info);

				}

		    array.Close();

			}

		}

	else if(aNode.NodeType() == TXmlEngNode::EAttribute)

		{

		TPtrC8 wsk1 = aNode.Name();

		TPtrC8 wsk2 = aNode.Value();

		info.Format(KInfoOnAttribute2,&wsk1,&wsk2);

		aFile.Write(info);

		}

	else if(aNode.NodeType() == TXmlEngNode::EText)

		{

		TPtrC8 wsk1 = aNode.AsText().Contents();

		info.Format(KInfoOnText,&wsk1);

		aFile.Write(info);

		}

	}

TBool CLibxml2Tester::CompareChars(const char* aString1,const char* aString2)

{

	TInt strLen = strlen(aString1);

	TInt desLen = strlen(aString2);

	if (strLen != desLen)

	{

		return FALSE;	

	}

	else

	{

		for(TInt i = 0; i < strLen; i++)

		{

			if (aString1[i] != aString2[i])

				return FALSE;			

		}

	}	

	return TRUE;

}

// -----------------------------------------------------------------------------

// CLibxml2Tester::CompareFilesL

// Comapare two files return true if the same

// -----------------------------------------------------------------------------

//

TInt CLibxml2Tester::CompareFilesL( CStifItemParser& aItem )

{

    _LIT(KSourceFileErrorName,"No source file name.");

    _LIT(KPatternFileErrorName,"No pattern file name.");

    _LIT(KSkipWhiteSpace,"Skipping white spaces in files.");

    _LIT(KCompareFilesInfo,"Comparing files: %S and %S");

    _LIT(KSourceFileError,"Source file error.");

    _LIT(KPatternFileError,"Pattern file error.");

    _LIT(KComparePassed,"Files compare test PASSED.");

    _LIT(KCompareFailed,"Files compare test FAILED.");

    TInt nResult = KErrNone;

    TBool skipWhite = FALSE;

    TBool foundRes = FALSE;

    TBool foundRef = FALSE;

    RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

    RFile srcFile;

    RFile referenceFile;

    TFileName srcFileName;

	TFileName referenceFileName;

    TPtrC SrcFile;

    if ( aItem.GetNextString(SrcFile) != KErrNone )

    {

        TestModuleIf().Printf( infoNum++, KTEST_NAME, 

                                KSourceFileErrorName);

     	iLog->Log((TDesC) KSourceFileErrorName);

     	nResult = KErrGeneral;

    }

    TPtrC ReferenceFile;

    if ( aItem.GetNextString(ReferenceFile) != KErrNone )

    {

        TestModuleIf().Printf( infoNum++, KTEST_NAME, 

                                KPatternFileErrorName);

     	iLog->Log((TDesC)KPatternFileErrorName);

        nResult = KErrGeneral;

    }

    TPtrC string;

    if ( aItem.GetNextString(string) == KErrNone )

    {

        TestModuleIf().Printf( infoNum++, KTEST_NAME, 

                                KSkipWhiteSpace);

     	iLog->Log((TDesC)KSkipWhiteSpace);

        skipWhite = TRUE;

    }

    if ( nResult == KErrNone )

	{

		srcFileName.Copy(SrcFile);

		referenceFileName.Copy(ReferenceFile);

		TestModuleIf().Printf( infoNum++, KTEST_NAME, 

    						KCompareFilesInfo, &SrcFile, &ReferenceFile);	

		iLog->Log(KCompareFilesInfo, &SrcFile, &ReferenceFile);

	    if(srcFile.Open(fs, srcFileName, EFileStream|EFileRead) == KErrNone)

		{

			// Does reference file exist.

			if(referenceFile.Open(fs, referenceFileName, EFileStream|EFileRead) == KErrNone)

		    {

		        // Integer variables for compare to length of files (result and reference).

		        TInt resSize;

		        TInt refSize;

		        srcFile.Size(resSize);

		        referenceFile.Size(refSize);

	            // Next compare one letter at the time, but only if files have same length.

	            if(skipWhite)

		        {

			        TBuf8<1> resBuf;

			        TBuf8<1> refBuf;

			        nResult = KErrNone;

			        TInt j = 0;

			        TInt i = 0;

			        //for(TInt i = 0; i < Size; i++)

			        while (TRUE)

				    {

				    	foundRes = FALSE;

				    	foundRef = FALSE;

				        // Read result file

				        while(i < (resSize + 1))

				        {

				        	i++;

				        	srcFile.Read(resBuf);