--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/xml/libxml2libs/test/xmlengtester/xmlengtester_emulator/src/xmlengtesterblocks.cpp Thu Dec 17 09:29:21 2009 +0200
@@ -0,0 +1,631 @@
+// 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 <domain/osextensions/StifParser.h>
+#include <domain/osextensions/Stiftestinterface.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);
+ resBuf.Trim();
+ if ( resBuf.Length() > 0)
+ {
+ foundRes = TRUE;
+ break;
+ }
+ }
+
+ // Read reference file
+ while(j < (refSize + 1))
+ {
+ j++;
+ referenceFile.Read(refBuf);
+ refBuf.Trim();
+ if ( refBuf.Length() > 0)
+ {
+ foundRef = TRUE;
+ break;
+ }
+ }
+
+ // Compare single letter at the time.
+ if( ( i < resSize ) && ( j < refSize ) && (resBuf[0] != refBuf[0]) )
+ {
+ nResult = KErrGeneral;
+ break;
+ }
+ if( (i == (resSize + 1)) && (j < refSize) && foundRef)
+ {
+ nResult = KErrGeneral;
+ break;
+ }
+ if( (i < resSize) && (j == (refSize + 1)) && foundRes)
+ {
+ nResult = KErrGeneral;
+ break;
+ }
+ if ((i > resSize) && (j > refSize))
+ break;
+ }
+ }
+ else
+ {
+ if (resSize != refSize)
+ nResult = KErrGeneral;
+ else
+ {
+ TBuf8<1> resBuf;
+ TBuf8<1> refBuf;
+ nResult = KErrNone;
+ for(TInt i = 0; i < resSize; i++)
+ {
+ // Read result file
+ srcFile.Read(resBuf);
+
+ // Read reference file
+ referenceFile.Read(refBuf);
+
+ // Compare single letter at the time.
+
+ if(resBuf[0] != refBuf[0])
+ {
+ nResult = KErrGeneral;
+ break;
+ }
+ }
+ }
+ }
+ referenceFile.Close();
+ srcFile.Close();
+ }
+ else
+ {
+ nResult = KErrGeneral;
+ TestModuleIf().Printf( infoNum++, KTEST_NAME, KPatternFileError);
+ iLog->Log((TDesC)KPatternFileError);
+ }
+ srcFile.Close();
+ }
+ else
+ {
+ nResult = KErrGeneral;
+ TestModuleIf().Printf( infoNum++, KTEST_NAME, KSourceFileError);
+ iLog->Log((TDesC)KSourceFileError);
+ }
+
+ }
+
+ CleanupStack::PopAndDestroy(&fs);
+
+ if ( nResult == KErrNone)
+ {
+ TestModuleIf().Printf( infoNum++, KTEST_NAME,KComparePassed);
+ iLog->Log((TDesC)KComparePassed);
+ }
+ else
+ {
+ TestModuleIf().Printf( infoNum++, KTEST_NAME, KCompareFailed);
+ iLog->Log((TDesC)KCompareFailed);
+ }
+
+ return nResult;
+ }