|
1 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 |
|
17 // INCLUDE FILES |
|
18 #include "TestContentHandler.h" |
|
19 #include "XMLOutputContentHandler.h" |
|
20 #include "xmlengtester.h" |
|
21 |
|
22 #include <e32svr.h> |
|
23 #include <e32math.h> |
|
24 #include <f32file.h> |
|
25 #include <domain/osextensions/StifParser.h> |
|
26 #include <domain/osextensions/Stiftestinterface.h> |
|
27 |
|
28 #include "xmlengtesterdef.h" |
|
29 #include <Xml\Parser.h> |
|
30 #include <Xml\ParserFeature.h> |
|
31 |
|
32 #include <libc\string.h> |
|
33 #include <charconv.h> |
|
34 #include <UTF.H> |
|
35 |
|
36 using namespace Xml; |
|
37 |
|
38 // ----------------------------------------------------------------------------- |
|
39 // CLibxml2Tester::Delete |
|
40 // Delete here all resources allocated and opened from test methods. |
|
41 // Called from destructor. |
|
42 // ----------------------------------------------------------------------------- |
|
43 // |
|
44 void CLibxml2Tester::Delete() |
|
45 { |
|
46 |
|
47 } |
|
48 |
|
49 // ----------------------------------------------------------------------------- |
|
50 // CLibxml2Tester::RunMethodL |
|
51 // Run specified method. Contains also table of test mothods and their names. |
|
52 // ----------------------------------------------------------------------------- |
|
53 // |
|
54 TInt CLibxml2Tester::RunMethodL( |
|
55 CStifItemParser& aItem ) |
|
56 { |
|
57 |
|
58 static TStifFunctionInfo const KFunctions[] = |
|
59 { |
|
60 // Copy this line for every implemented function. |
|
61 // First string is the function name used in TestScripter script file. |
|
62 // Second is the actual implementation member function. |
|
63 |
|
64 // test |
|
65 ENTRY( "CompareFiles", CLibxml2Tester::CompareFilesL ), |
|
66 |
|
67 // sax |
|
68 ENTRY( "SAXParseFile", CLibxml2Tester::ParseFileSAXL ), |
|
69 ENTRY( "SAXParseBuffer", CLibxml2Tester::ParseBufSAXL ), |
|
70 ENTRY( "SAXParseFileWithNameSpaceMapping", CLibxml2Tester::ParseFileSAXNSL ), |
|
71 ENTRY( "SAXParseFileWithTagToLowerCase", CLibxml2Tester::ParseFileSAXLowerCaseL ), |
|
72 ENTRY( "SAXParseFileWithExternalSubsetFeature", CLibxml2Tester::ParseFileSAXExternalSubsetL ), |
|
73 |
|
74 // dom |
|
75 ENTRY( "ParseFile", CLibxml2Tester::ParseFileDomL ), |
|
76 ENTRY( "SaveXmlToFile", CLibxml2Tester::SaveXmlToFileDomL ), |
|
77 ENTRY( "CheckOuterXml", CLibxml2Tester::CheckOuterXmlL ), |
|
78 ENTRY( "CheckInnerXml", CLibxml2Tester::CheckInnerXmlL ), |
|
79 ENTRY( "CreateDocument", CLibxml2Tester::CreateDocumentL ), |
|
80 ENTRY( "CheckDocumentParameters", CLibxml2Tester::CheckDocumentParametersL ), |
|
81 ENTRY( "CreateDocumentElement", CLibxml2Tester::CreateDocumentElementL ), |
|
82 ENTRY( "CreateDocumentFromNode", CLibxml2Tester::CreateDocumentFromNodeL ), |
|
83 ENTRY( "SaveXmlToUTF16LE", CLibxml2Tester::SaveXmlToBufferUTF16L ), |
|
84 ENTRY( "TestNodeFilter1", CLibxml2Tester::TestNodeFilterL ), |
|
85 ENTRY( "CloneDocument", CLibxml2Tester::CloneDocumentL ), |
|
86 ENTRY( "CheckNotNullElement", CLibxml2Tester::CheckNotNullElementL ), |
|
87 ENTRY( "CheckSiblingFunctions", CLibxml2Tester::CheckSiblingFunctionsL ), |
|
88 ENTRY( "CheckNodeParameters", CLibxml2Tester::CheckNodeParametersL ), |
|
89 ENTRY( "ParentNodes", CLibxml2Tester::ParentNodesL ), |
|
90 //ENTRY( "NameModification", CLibxml2Tester::NameModificationL ), |
|
91 ENTRY( "CheckNamespaces", CLibxml2Tester::CheckNamespacesL ), |
|
92 ENTRY( "CheckProcessingInstruction", CLibxml2Tester::CheckProcessingInstructionL ), |
|
93 ENTRY( "CheckComments", CLibxml2Tester::CheckCommentsL ), |
|
94 ENTRY( "CheckCDATA", CLibxml2Tester::CheckCDATAL ), |
|
95 ENTRY( "CheckTextNode", CLibxml2Tester::CheckTextNodeL ), |
|
96 //ENTRY( "CheckDocumentFragment", CLibxml2Tester::CheckDocumentFragmentL ), |
|
97 ENTRY( "NodeNamespacePocessing", CLibxml2Tester::NodeNamespacePocessingL ), |
|
98 ENTRY( "CheckEntityRef", CLibxml2Tester::CheckEntityRefL ), |
|
99 ENTRY( "NodeTreeModification", CLibxml2Tester::NodeTreeModificationL ), |
|
100 ENTRY( "NodeTreeDeleting", CLibxml2Tester::NodeTreeDeletingL ), |
|
101 ENTRY( "CheckNodeList", CLibxml2Tester::CheckNodeListL ), |
|
102 ENTRY( "ElementNamespacePocessing", CLibxml2Tester::ElementNamespacePocessingL ), |
|
103 ENTRY( "CheckAttributes", CLibxml2Tester::CheckAttributesL ), |
|
104 ENTRY( "CheckElementAttributes", CLibxml2Tester::CheckElementAttributesL ), |
|
105 ENTRY( "CheckModifAttributes", CLibxml2Tester::CheckModifAttributesL ), |
|
106 ENTRY( "AddingAttributes", CLibxml2Tester::AddingAttributesL ), |
|
107 ENTRY( "AddingElements", CLibxml2Tester::AddingElementsL ), |
|
108 ENTRY( "CheckModifElement", CLibxml2Tester::CheckModifElementL ), |
|
109 ENTRY( "SetElementText", CLibxml2Tester::SetElementTextL ), |
|
110 ENTRY( "WHAT", CLibxml2Tester::CheckNextL ), |
|
111 ENTRY( "AddXmlId", CLibxml2Tester::AddXmlIdL ), |
|
112 ENTRY( "FindXmlId", CLibxml2Tester::FindXmlIdL ), |
|
113 ENTRY( "SetTextNoEncTest", CLibxml2Tester::SetTextNoEncTestL), |
|
114 ENTRY( "AppendTextNoEncTest", CLibxml2Tester::AppendTextNoEncTestL), |
|
115 ENTRY( "SetValueNoEncTest", CLibxml2Tester::SetValueNoEncTestL), |
|
116 ENTRY( "CreateDocument2", CLibxml2Tester::CreateDocument2L), |
|
117 ENTRY( "CreateEntityReferenceTest", CLibxml2Tester::CreateEntityReferenceTestL), |
|
118 ENTRY( "ParseFileDom2", CLibxml2Tester::ParseFileDom2L), |
|
119 ENTRY( "ParseFileDom3", CLibxml2Tester::ParseFileDom3L), |
|
120 ENTRY( "LookupNamespaceByPrefixTest", CLibxml2Tester::LookupNamespaceByPrefixTestL), |
|
121 ENTRY( "LookupNamespaceByUriTest", CLibxml2Tester::LookupNamespaceByUriTestL), |
|
122 ENTRY( "LookupNamespaceByPrefixTest2", CLibxml2Tester::LookupNamespaceByPrefixTest2L), |
|
123 ENTRY( "LookupNamespaceByUriTest2", CLibxml2Tester::LookupNamespaceByUriTest2L), |
|
124 ENTRY( "RemoveChildrenTest", CLibxml2Tester::RemoveChildrenTestL), |
|
125 ENTRY( "UserDataTest", CLibxml2Tester::UserDataTestL), |
|
126 ENTRY( "BaseUriTest", CLibxml2Tester::BaseUriTestL), |
|
127 ENTRY( "AddXmlIdTest", CLibxml2Tester::AddXmlIdTestL), |
|
128 ENTRY( "AddXmlId2", CLibxml2Tester::AddXmlId2L), |
|
129 ENTRY( "AddXmlId3", CLibxml2Tester::AddXmlId3L), |
|
130 |
|
131 //chunkparser |
|
132 ENTRY( "ParseFileChunk", CLibxml2Tester::ParseFileChunkL ), |
|
133 |
|
134 //chunkcontainer |
|
135 ENTRY("ChunkContainerGetList",CLibxml2Tester::ChunkContainer_GetListL), |
|
136 ENTRY("ChunkContainerCid",CLibxml2Tester::ChunkContainer_CidL), |
|
137 ENTRY("ChunkContainerCidError",CLibxml2Tester::ChunkContainer_CidErrorL), |
|
138 ENTRY("ChunkContainerChunk",CLibxml2Tester::ChunkContainer_ChunkL), |
|
139 ENTRY("ChunkContainerOffset",CLibxml2Tester::ChunkContainer_OffsetL), |
|
140 ENTRY("ChunkContainerSize",CLibxml2Tester::ChunkContainer_SizeL), |
|
141 ENTRY("ChunkContainerNodeType",CLibxml2Tester::ChunkContainer_NodeTypeL), |
|
142 ENTRY("ChunkContainerRemove",CLibxml2Tester::ChunkContainer_RemoveL), |
|
143 ENTRY("ChunkContainerRemove2",CLibxml2Tester::ChunkContainer_Remove2L), |
|
144 ENTRY("ChunkContainerRemove3",CLibxml2Tester::ChunkContainer_Remove3L), |
|
145 ENTRY("ChunkContainerUnlink",CLibxml2Tester::ChunkContainer_UnlinkL), |
|
146 ENTRY("ChunkContainerReplaceWith",CLibxml2Tester::ChunkContainer_ReplaceWithL), |
|
147 ENTRY("ChunkContainerSubstituteFor",CLibxml2Tester::ChunkContainer_SubstituteForL), |
|
148 ENTRY("ChunkContainerCopy",CLibxml2Tester::ChunkContainer_CopyL), |
|
149 ENTRY("ChunkContainerCopy2",CLibxml2Tester::ChunkContainer_Copy2L), |
|
150 ENTRY("ChunkContainerCopy3",CLibxml2Tester::ChunkContainer_Copy3L), |
|
151 ENTRY("ChunkContainerCopy4",CLibxml2Tester::ChunkContainer_Copy4L), |
|
152 ENTRY("ChunkContainerCopyTo",CLibxml2Tester::ChunkContainer_CopyToL), |
|
153 ENTRY("ChunkContainerClone",CLibxml2Tester::ChunkContainer_CloneL), |
|
154 ENTRY("ChunkContainerAdoptNode",CLibxml2Tester::ChunkContainer_AdoptNodeL), |
|
155 ENTRY("ChunkContainerSetAsFirstSibling",CLibxml2Tester::ChunkContainer_SetAsFirstSiblingL), |
|
156 ENTRY("ChunkContainerSetAsLastSibling",CLibxml2Tester::ChunkContainer_SetAsLastSiblingL), |
|
157 ENTRY("ChunkContainerMoveBeforeSibling",CLibxml2Tester::ChunkContainer_MoveBeforeSiblingL), |
|
158 ENTRY("ChunkContainerMoveAfterSibling",CLibxml2Tester::ChunkContainer_MoveAfterSiblingL), |
|
159 ENTRY("ChunkContainerMoveTo",CLibxml2Tester::ChunkContainer_MoveToL), |
|
160 ENTRY("ChunkContainerReconcileNamespaces",CLibxml2Tester::ChunkContainer_ReconcileNamespacesL), |
|
161 |
|
162 //filecontainer |
|
163 ENTRY("FileContainerGetList",CLibxml2Tester::FileContainer_GetListL), |
|
164 ENTRY("FileContainerCid",CLibxml2Tester::FileContainer_CidL), |
|
165 ENTRY("FileContainerCidError",CLibxml2Tester::FileContainer_CidErrorL), |
|
166 ENTRY("FileContainerSize",CLibxml2Tester::FileContainer_SizeL), |
|
167 ENTRY("FileContainerFile",CLibxml2Tester::FileContainer_FileL), |
|
168 ENTRY("FileContainerNodeType",CLibxml2Tester::FileContainer_NodeTypeL), |
|
169 ENTRY("FileContainerRemove",CLibxml2Tester::FileContainer_RemoveL), |
|
170 ENTRY("FileContainerRemove2",CLibxml2Tester::FileContainer_Remove2L), |
|
171 ENTRY("FileContainerRemove3",CLibxml2Tester::FileContainer_Remove3L), |
|
172 ENTRY("FileContainerUnlink",CLibxml2Tester::FileContainer_UnlinkL), |
|
173 ENTRY("FileContainerReplaceWith",CLibxml2Tester::FileContainer_ReplaceWithL), |
|
174 ENTRY("FileContainerSubstituteFor",CLibxml2Tester::FileContainer_SubstituteForL), |
|
175 ENTRY("FileContainerCopy",CLibxml2Tester::FileContainer_CopyL), |
|
176 ENTRY("FileContainerCopy2",CLibxml2Tester::FileContainer_Copy2L), |
|
177 ENTRY("FileContainerCopy3",CLibxml2Tester::FileContainer_Copy3L), |
|
178 ENTRY("FileContainerCopy4",CLibxml2Tester::FileContainer_Copy4L), |
|
179 ENTRY("FileContainerCopyTo",CLibxml2Tester::FileContainer_CopyToL), |
|
180 ENTRY("FileContainerClone",CLibxml2Tester::FileContainer_CloneL), |
|
181 ENTRY("FileContainerAdoptNode",CLibxml2Tester::FileContainer_AdoptNodeL), |
|
182 ENTRY("FileContainerSetAsFirstSibling",CLibxml2Tester::FileContainer_SetAsFirstSiblingL), |
|
183 ENTRY("FileContainerSetAsLastSibling",CLibxml2Tester::FileContainer_SetAsLastSiblingL), |
|
184 ENTRY("FileContainerMoveBeforeSibling",CLibxml2Tester::FileContainer_MoveBeforeSiblingL), |
|
185 ENTRY("FileContainerMoveAfterSibling",CLibxml2Tester::FileContainer_MoveAfterSiblingL), |
|
186 ENTRY("FileContainerMoveTo",CLibxml2Tester::FileContainer_MoveToL), |
|
187 ENTRY("FileContainerReconcileNamespaces",CLibxml2Tester::FileContainer_ReconcileNamespacesL), |
|
188 |
|
189 // Binary Container |
|
190 ENTRY( "BinaryContainer", CLibxml2Tester::BinaryContainerL), |
|
191 ENTRY( "PartialBinaryContainer", CLibxml2Tester::PartialBinaryContainerL ), |
|
192 ENTRY( "TestAppendContents", CLibxml2Tester::TestAppendContentsL), |
|
193 ENTRY("BinaryContainerGetList",CLibxml2Tester::BinaryContainer_GetListL), |
|
194 ENTRY("BinaryContainerGetList2",CLibxml2Tester::BinaryContainer_GetList2L), |
|
195 ENTRY("BinaryContainerCidError",CLibxml2Tester::BinaryContainer_CidErrorL), |
|
196 ENTRY("BinaryContainerRemove",CLibxml2Tester::BinaryContainer_RemoveL), |
|
197 ENTRY("BinaryContainerRemove2",CLibxml2Tester::BinaryContainer_Remove2L), |
|
198 ENTRY("BinaryContainerRemove3",CLibxml2Tester::BinaryContainer_Remove3L), |
|
199 ENTRY("BinaryContainerUnlink",CLibxml2Tester::BinaryContainer_UnlinkL), |
|
200 ENTRY("BinaryContainerReplaceWith",CLibxml2Tester::BinaryContainer_ReplaceWithL), |
|
201 ENTRY("BinaryContainerSubstituteFor",CLibxml2Tester::BinaryContainer_SubstituteForL), |
|
202 ENTRY("BinaryContainerCopy",CLibxml2Tester::BinaryContainer_CopyL), |
|
203 ENTRY("BinaryContainerCopy2",CLibxml2Tester::BinaryContainer_Copy2L), |
|
204 ENTRY("BinaryContainerCopy3",CLibxml2Tester::BinaryContainer_Copy3L), |
|
205 ENTRY("BinaryContainerCopy4",CLibxml2Tester::BinaryContainer_Copy4L), |
|
206 ENTRY("BinaryContainerCopyTo",CLibxml2Tester::BinaryContainer_CopyToL), |
|
207 ENTRY("BinaryContainerClone",CLibxml2Tester::BinaryContainer_CloneL), |
|
208 ENTRY("BinaryContainerAdoptNode",CLibxml2Tester::BinaryContainer_AdoptNodeL), |
|
209 ENTRY("BinaryContainerSetAsFirstSibling",CLibxml2Tester::BinaryContainer_SetAsFirstSiblingL), |
|
210 ENTRY("BinaryContainerSetAsLastSibling",CLibxml2Tester::BinaryContainer_SetAsLastSiblingL), |
|
211 ENTRY("BinaryContainerMoveBeforeSibling",CLibxml2Tester::BinaryContainer_MoveBeforeSiblingL), |
|
212 ENTRY("BinaryContainerMoveAfterSibling",CLibxml2Tester::BinaryContainer_MoveAfterSiblingL), |
|
213 ENTRY("BinaryContainerMoveTo",CLibxml2Tester::BinaryContainer_MoveToL), |
|
214 ENTRY("BinaryContainerReconcileNamespaces",CLibxml2Tester::BinaryContainer_ReconcileNamespacesL), |
|
215 |
|
216 // XPath |
|
217 ENTRY( "Evaluate", CLibxml2Tester::EvaluateExpressionL ), |
|
218 ENTRY( "SaveResult", CLibxml2Tester::SaveResultL ), |
|
219 ENTRY( "ToNumber", CLibxml2Tester::ToNumberL ), |
|
220 ENTRY( "ToBool", CLibxml2Tester::ToBoolL ), |
|
221 ENTRY( "ToString", CLibxml2Tester::ToStringL ), |
|
222 ENTRY( "Instances", CLibxml2Tester::InstanceL ), |
|
223 ENTRY( "ExtVector", CLibxml2Tester::ExtensionVectorL ), |
|
224 ENTRY( "ExtFunction", CLibxml2Tester::ExtensionFunctionL ), |
|
225 |
|
226 // Utils |
|
227 ENTRY( "EscapeForXmlValue", CLibxml2Tester::UtilsEscapeForXmlValueL ), |
|
228 ENTRY( "XmlCharFromDes", CLibxml2Tester::UtilsXmlCharFromDesL ), |
|
229 ENTRY( "XmlCharFromDes8", CLibxml2Tester::UtilsXmlCharFromDes8L ), |
|
230 |
|
231 // Serialize Default |
|
232 ENTRY( "SerializeDefaultFile", CLibxml2Tester::SerializeDefaultFileL), |
|
233 |
|
234 // Serialize XOP |
|
235 ENTRY( "SerializeXOP", CLibxml2Tester::SerializeXOPL), |
|
236 ENTRY( "DirtySerializeXOP", CLibxml2Tester::DirtySerializeXOPL), |
|
237 ENTRY( "SerializeXopSoap", CLibxml2Tester::SerializeXopSoapL), |
|
238 ENTRY( "MultiSerializeXopSoap", CLibxml2Tester::MultiSerializeXopSoapL), |
|
239 ENTRY( "SerializeXopFile", CLibxml2Tester::SerializeXopFileL), |
|
240 ENTRY( "SerializeXopFileDirty", CLibxml2Tester::SerializeXopFileDirtyL), |
|
241 ENTRY( "SerializeXopDirtySoap", CLibxml2Tester::SerializeXopDirtySoapL), |
|
242 ENTRY( "SerializeXopBuffer", CLibxml2Tester::SerializeXopBufferL), |
|
243 ENTRY( "Serxop3diffCont", CLibxml2Tester::Serxop3diffContL), |
|
244 |
|
245 //Serialize GZIP |
|
246 ENTRY( "SerializeGZIP", CLibxml2Tester::SerializeGZIPL), |
|
247 ENTRY( "DecompressGZIP", CLibxml2Tester::DecompressGZIPL), |
|
248 ENTRY( "DecompressBufferGZIP", CLibxml2Tester::DecompressBufferGZIPL), |
|
249 ENTRY( "CompressBufferGZIP", CLibxml2Tester::CompressBufferGZIPL), |
|
250 ENTRY( "SerializeDirtyGzip", CLibxml2Tester::SerializeDirtyGzipL), |
|
251 |
|
252 //Serializer |
|
253 ENTRY( "TestSerializer", CLibxml2Tester::TestSerializerL), |
|
254 ENTRY( "TestSetOutputBuffer", CLibxml2Tester::TestSetOutputBufferL), |
|
255 ENTRY( "TestSetOutputFile", CLibxml2Tester::TestSetOutputFileL), |
|
256 ENTRY( "TestSetOutputStream", CLibxml2Tester::TestSetOutputStreamL), |
|
257 ENTRY( "TestSerializationOptions", CLibxml2Tester::TestSerializationOptionsL), |
|
258 ENTRY( "TestSerializeFile1", CLibxml2Tester::TestSerializeFile1L), |
|
259 ENTRY( "TestSerializeFile2", CLibxml2Tester::TestSerializeFile2L), |
|
260 ENTRY( "TestSerializeFile3", CLibxml2Tester::TestSerializeFile3L), |
|
261 ENTRY( "TestSerializeBuffer", CLibxml2Tester::TestSerializeBufferL), |
|
262 ENTRY( "TestSerializePartTree", CLibxml2Tester::TestSerializePartTreeL), |
|
263 ENTRY( "TestSerializeFileBuffer", CLibxml2Tester::TestSerializeFileBufferL), |
|
264 ENTRY( "TestSerializeChilds", CLibxml2Tester::TestSerializeChildsL), |
|
265 ENTRY( "TestSerializeFileConvinience", CLibxml2Tester::TestSerializeFileConvinienceL), |
|
266 ENTRY( "TestSerializeBufferConvinience", CLibxml2Tester::TestSerializeBufferConvinienceL), |
|
267 ENTRY( "TestMultipleSerializeToBuffer", CLibxml2Tester::TestMultipleSerializeToBufferL), |
|
268 ENTRY( "TestSerializationOptionsBuffer", CLibxml2Tester::TestSerializationOptionsBufferL), |
|
269 ENTRY( "TestContentType", CLibxml2Tester::TestContentTypeL), |
|
270 |
|
271 //Deserialize |
|
272 ENTRY( "Deserialize", CLibxml2Tester::DeserializeL), |
|
273 ENTRY( "Deserialize2", CLibxml2Tester::Deserialize2L), |
|
274 ENTRY( "DeserializeFromFile", CLibxml2Tester::DeserializeFromFileL), |
|
275 ENTRY( "DeserializeFromBuffer", CLibxml2Tester::DeserializeFromBufferL), |
|
276 ENTRY( "TestDeserializer", CLibxml2Tester::TestDeserializerL), |
|
277 ENTRY( "TestSetInputFile", CLibxml2Tester::TestSetInputFileL), |
|
278 ENTRY( "TestSetInputBuffer", CLibxml2Tester::TestSetInputBufferL), |
|
279 ENTRY( "TestSetContentHandler", CLibxml2Tester::TestSetContentHandlerL), |
|
280 ENTRY( "TestEnableFeature", CLibxml2Tester::TestEnableFeatureL), |
|
281 ENTRY( "TestDisableFeature", CLibxml2Tester::TestDisableFeatureL), |
|
282 ENTRY( "TestIsFeatureEnabled", CLibxml2Tester::TestIsFeatureEnabledL), |
|
283 ENTRY( "TestUseExternalData", CLibxml2Tester::TestUseExternalDataL), |
|
284 ENTRY( "TestExternalData", CLibxml2Tester::TestExternalDataL), |
|
285 ENTRY( "TestDesFileConvinience", CLibxml2Tester::TestDesFileConvinienceL), |
|
286 ENTRY( "TestDesBufferConvinience", CLibxml2Tester::TestDesBufferConvinienceL), |
|
287 ENTRY( "TestDeserializerBuffer", CLibxml2Tester::TestDeserializerBufferL), |
|
288 ENTRY( "TestSetParsingOptions1", CLibxml2Tester::TestSetParsingOptions1L), |
|
289 ENTRY( "DeserializeInfoset", CLibxml2Tester::DeserializeInfosetL), |
|
290 ENTRY( "Deserialize2Infoset", CLibxml2Tester::Deserialize2InfosetL), |
|
291 ENTRY( "DeserializeFromFileInfoset", CLibxml2Tester::DeserializeFromFileInfosetL), |
|
292 ENTRY( "DeserializeFromBufferInfoset", CLibxml2Tester::DeserializeFromBufferInfosetL), |
|
293 ENTRY( "TestDeserializerInfoset", CLibxml2Tester::TestDeserializerInfosetL), |
|
294 ENTRY( "TestSetInputFileInfoset", CLibxml2Tester::TestSetInputFileInfosetL), |
|
295 ENTRY( "TestSetInputBufferInfoset", CLibxml2Tester::TestSetInputBufferInfosetL), |
|
296 ENTRY( "TestSetContentHandlerInfoset", CLibxml2Tester::TestSetContentHandlerInfosetL), |
|
297 ENTRY( "TestEnableFeatureInfoset", CLibxml2Tester::TestEnableFeatureInfosetL), |
|
298 ENTRY( "TestDisableFeatureInfoset", CLibxml2Tester::TestDisableFeatureInfosetL), |
|
299 ENTRY( "TestIsFeatureEnabledInfoset", CLibxml2Tester::TestIsFeatureEnabledInfosetL), |
|
300 ENTRY( "TestUseExternalDataInfoset", CLibxml2Tester::TestUseExternalDataInfosetL), |
|
301 ENTRY( "TestExternalDataInfoset", CLibxml2Tester::TestExternalDataInfosetL), |
|
302 ENTRY( "TestDesFileConvinienceInfoset", CLibxml2Tester::TestDesFileConvinienceInfosetL), |
|
303 ENTRY( "TestDesBufferConvinienceInfoset", CLibxml2Tester::TestDesBufferConvinienceInfosetL), |
|
304 ENTRY( "TestDeserializerBufferInfoset", CLibxml2Tester::TestDeserializerBufferInfosetL), |
|
305 |
|
306 //DOMDeserialize |
|
307 ENTRY( "DOMDeserialize", CLibxml2Tester::DOMDeserializeL), |
|
308 ENTRY( "DOMDeserialize2", CLibxml2Tester::DOMDeserialize2L), |
|
309 ENTRY( "DOMDeserializeFromFile", CLibxml2Tester::DOMDeserializeFromFileL), |
|
310 ENTRY( "DOMDeserializeFromFile2", CLibxml2Tester::DOMDeserializeFromFile2L), |
|
311 ENTRY( "DOMDeserializeFromBuffer", CLibxml2Tester::DOMDeserializeFromBufferL), |
|
312 ENTRY( "TestDOMDeserializer", CLibxml2Tester::TestDOMDeserializerL), |
|
313 ENTRY( "TestDOMSetInputFile", CLibxml2Tester::TestDOMSetInputFileL), |
|
314 ENTRY( "TestDOMSetInputBuffer", CLibxml2Tester::TestDOMSetInputBufferL), |
|
315 ENTRY( "TestDOMUseExternalData", CLibxml2Tester::TestDOMUseExternalDataL), |
|
316 ENTRY( "TestDOMExternalData", CLibxml2Tester::TestDOMExternalDataL) |
|
317 }; |
|
318 |
|
319 const TInt count = sizeof( KFunctions ) / |
|
320 sizeof( TStifFunctionInfo ); |
|
321 |
|
322 return RunInternalL( KFunctions, count, aItem ); |
|
323 |
|
324 } |
|
325 |
|
326 /****************************** TEST **************************************/ |
|
327 |
|
328 TBool CLibxml2Tester::CompareDescAndChar(const char* aString,TDesC8& aDesc) |
|
329 { |
|
330 TInt strLen = strlen(aString); |
|
331 TInt desLen = aDesc.Length(); |
|
332 if (strLen != desLen) |
|
333 { |
|
334 return FALSE; |
|
335 } |
|
336 else |
|
337 { |
|
338 for(TInt i = 0; i < strLen; i++) |
|
339 { |
|
340 if (aString[i] != aDesc[i]) |
|
341 return FALSE; |
|
342 } |
|
343 } |
|
344 return TRUE; |
|
345 } |
|
346 |
|
347 TBool CLibxml2Tester::CompareDescAndChar(const TUint8* aString,TDesC8& aDesc) |
|
348 { |
|
349 TInt strLen = strlen((char*)aString); |
|
350 TInt desLen = aDesc.Length(); |
|
351 if (strLen != desLen) |
|
352 { |
|
353 return FALSE; |
|
354 } |
|
355 else |
|
356 { |
|
357 for(TInt i = 0; i < strLen; i++) |
|
358 { |
|
359 if (aString[i] != aDesc[i]) |
|
360 return FALSE; |
|
361 } |
|
362 } |
|
363 return TRUE; |
|
364 } |
|
365 |
|
366 void CLibxml2Tester::SaveNode(RFile aFile,TXmlEngNode aNode) |
|
367 { |
|
368 _LIT8(KInfoOnStartEle,"Element: %S \r\n"); |
|
369 _LIT8(KInfoOnAttribute,"\tAttribute \tname: %S \t value: %S \r\n"); |
|
370 _LIT8(KInfoOnAttribute2,"Attribute \tname: %S \t value: %S \r\n"); |
|
371 _LIT8(KInfoOnText,"Text: %S\r\n"); |
|
372 |
|
373 TBuf8<256> info; |
|
374 |
|
375 if(aNode.NodeType() == TXmlEngNode::EElement) |
|
376 { |
|
377 TPtrC8 wsk = aNode.Name(); |
|
378 info.Format(KInfoOnStartEle,&wsk); |
|
379 aFile.Write(info); |
|
380 |
|
381 RXmlEngNodeList <TXmlEngAttr> array; |
|
382 if(aNode.HasAttributes()) |
|
383 { |
|
384 aNode.AsElement().GetAttributes(array); |
|
385 while(array.HasNext()) |
|
386 { |
|
387 TXmlEngAttr attr = array.Next(); |
|
388 TPtrC8 wsk1 = attr.Name(); |
|
389 TPtrC8 wsk2 = attr.Value(); |
|
390 info.Format(KInfoOnAttribute,&wsk1,&wsk2); |
|
391 aFile.Write(info); |
|
392 } |
|
393 array.Close(); |
|
394 } |
|
395 } |
|
396 else if(aNode.NodeType() == TXmlEngNode::EAttribute) |
|
397 { |
|
398 TPtrC8 wsk1 = aNode.Name(); |
|
399 TPtrC8 wsk2 = aNode.Value(); |
|
400 info.Format(KInfoOnAttribute2,&wsk1,&wsk2); |
|
401 aFile.Write(info); |
|
402 } |
|
403 else if(aNode.NodeType() == TXmlEngNode::EText) |
|
404 { |
|
405 TPtrC8 wsk1 = aNode.AsText().Contents(); |
|
406 info.Format(KInfoOnText,&wsk1); |
|
407 aFile.Write(info); |
|
408 } |
|
409 } |
|
410 |
|
411 TBool CLibxml2Tester::CompareChars(const char* aString1,const char* aString2) |
|
412 { |
|
413 TInt strLen = strlen(aString1); |
|
414 TInt desLen = strlen(aString2); |
|
415 if (strLen != desLen) |
|
416 { |
|
417 return FALSE; |
|
418 } |
|
419 else |
|
420 { |
|
421 for(TInt i = 0; i < strLen; i++) |
|
422 { |
|
423 if (aString1[i] != aString2[i]) |
|
424 return FALSE; |
|
425 } |
|
426 } |
|
427 return TRUE; |
|
428 } |
|
429 |
|
430 // ----------------------------------------------------------------------------- |
|
431 // CLibxml2Tester::CompareFilesL |
|
432 // Comapare two files return true if the same |
|
433 // ----------------------------------------------------------------------------- |
|
434 // |
|
435 TInt CLibxml2Tester::CompareFilesL( CStifItemParser& aItem ) |
|
436 { |
|
437 _LIT(KSourceFileErrorName,"No source file name."); |
|
438 _LIT(KPatternFileErrorName,"No pattern file name."); |
|
439 _LIT(KSkipWhiteSpace,"Skipping white spaces in files."); |
|
440 _LIT(KCompareFilesInfo,"Comparing files: %S and %S"); |
|
441 _LIT(KSourceFileError,"Source file error."); |
|
442 _LIT(KPatternFileError,"Pattern file error."); |
|
443 _LIT(KComparePassed,"Files compare test PASSED."); |
|
444 _LIT(KCompareFailed,"Files compare test FAILED."); |
|
445 |
|
446 TInt nResult = KErrNone; |
|
447 |
|
448 TBool skipWhite = FALSE; |
|
449 TBool foundRes = FALSE; |
|
450 TBool foundRef = FALSE; |
|
451 |
|
452 RFs fs; |
|
453 User::LeaveIfError(fs.Connect()); |
|
454 CleanupClosePushL(fs); |
|
455 |
|
456 RFile srcFile; |
|
457 RFile referenceFile; |
|
458 |
|
459 TFileName srcFileName; |
|
460 TFileName referenceFileName; |
|
461 |
|
462 TPtrC SrcFile; |
|
463 if ( aItem.GetNextString(SrcFile) != KErrNone ) |
|
464 { |
|
465 TestModuleIf().Printf( infoNum++, KTEST_NAME, |
|
466 KSourceFileErrorName); |
|
467 iLog->Log((TDesC) KSourceFileErrorName); |
|
468 nResult = KErrGeneral; |
|
469 } |
|
470 |
|
471 TPtrC ReferenceFile; |
|
472 if ( aItem.GetNextString(ReferenceFile) != KErrNone ) |
|
473 { |
|
474 TestModuleIf().Printf( infoNum++, KTEST_NAME, |
|
475 KPatternFileErrorName); |
|
476 iLog->Log((TDesC)KPatternFileErrorName); |
|
477 nResult = KErrGeneral; |
|
478 } |
|
479 |
|
480 TPtrC string; |
|
481 if ( aItem.GetNextString(string) == KErrNone ) |
|
482 { |
|
483 TestModuleIf().Printf( infoNum++, KTEST_NAME, |
|
484 KSkipWhiteSpace); |
|
485 iLog->Log((TDesC)KSkipWhiteSpace); |
|
486 skipWhite = TRUE; |
|
487 } |
|
488 |
|
489 if ( nResult == KErrNone ) |
|
490 { |
|
491 srcFileName.Copy(SrcFile); |
|
492 referenceFileName.Copy(ReferenceFile); |
|
493 |
|
494 TestModuleIf().Printf( infoNum++, KTEST_NAME, |
|
495 KCompareFilesInfo, &SrcFile, &ReferenceFile); |
|
496 iLog->Log(KCompareFilesInfo, &SrcFile, &ReferenceFile); |
|
497 |
|
498 if(srcFile.Open(fs, srcFileName, EFileStream|EFileRead) == KErrNone) |
|
499 { |
|
500 // Does reference file exist. |
|
501 if(referenceFile.Open(fs, referenceFileName, EFileStream|EFileRead) == KErrNone) |
|
502 { |
|
503 // Integer variables for compare to length of files (result and reference). |
|
504 TInt resSize; |
|
505 TInt refSize; |
|
506 |
|
507 srcFile.Size(resSize); |
|
508 referenceFile.Size(refSize); |
|
509 |
|
510 // Next compare one letter at the time, but only if files have same length. |
|
511 if(skipWhite) |
|
512 { |
|
513 TBuf8<1> resBuf; |
|
514 TBuf8<1> refBuf; |
|
515 nResult = KErrNone; |
|
516 TInt j = 0; |
|
517 TInt i = 0; |
|
518 |
|
519 //for(TInt i = 0; i < Size; i++) |
|
520 while (TRUE) |
|
521 { |
|
522 foundRes = FALSE; |
|
523 foundRef = FALSE; |
|
524 // Read result file |
|
525 while(i < (resSize + 1)) |
|
526 { |
|
527 i++; |
|
528 srcFile.Read(resBuf); |
|
529 resBuf.Trim(); |
|
530 if ( resBuf.Length() > 0) |
|
531 { |
|
532 foundRes = TRUE; |
|
533 break; |
|
534 } |
|
535 } |
|
536 |
|
537 // Read reference file |
|
538 while(j < (refSize + 1)) |
|
539 { |
|
540 j++; |
|
541 referenceFile.Read(refBuf); |
|
542 refBuf.Trim(); |
|
543 if ( refBuf.Length() > 0) |
|
544 { |
|
545 foundRef = TRUE; |
|
546 break; |
|
547 } |
|
548 } |
|
549 |
|
550 // Compare single letter at the time. |
|
551 if( ( i < resSize ) && ( j < refSize ) && (resBuf[0] != refBuf[0]) ) |
|
552 { |
|
553 nResult = KErrGeneral; |
|
554 break; |
|
555 } |
|
556 if( (i == (resSize + 1)) && (j < refSize) && foundRef) |
|
557 { |
|
558 nResult = KErrGeneral; |
|
559 break; |
|
560 } |
|
561 if( (i < resSize) && (j == (refSize + 1)) && foundRes) |
|
562 { |
|
563 nResult = KErrGeneral; |
|
564 break; |
|
565 } |
|
566 if ((i > resSize) && (j > refSize)) |
|
567 break; |
|
568 } |
|
569 } |
|
570 else |
|
571 { |
|
572 if (resSize != refSize) |
|
573 nResult = KErrGeneral; |
|
574 else |
|
575 { |
|
576 TBuf8<1> resBuf; |
|
577 TBuf8<1> refBuf; |
|
578 nResult = KErrNone; |
|
579 for(TInt i = 0; i < resSize; i++) |
|
580 { |
|
581 // Read result file |
|
582 srcFile.Read(resBuf); |
|
583 |
|
584 // Read reference file |
|
585 referenceFile.Read(refBuf); |
|
586 |
|
587 // Compare single letter at the time. |
|
588 |
|
589 if(resBuf[0] != refBuf[0]) |
|
590 { |
|
591 nResult = KErrGeneral; |
|
592 break; |
|
593 } |
|
594 } |
|
595 } |
|
596 } |
|
597 referenceFile.Close(); |
|
598 srcFile.Close(); |
|
599 } |
|
600 else |
|
601 { |
|
602 nResult = KErrGeneral; |
|
603 TestModuleIf().Printf( infoNum++, KTEST_NAME, KPatternFileError); |
|
604 iLog->Log((TDesC)KPatternFileError); |
|
605 } |
|
606 srcFile.Close(); |
|
607 } |
|
608 else |
|
609 { |
|
610 nResult = KErrGeneral; |
|
611 TestModuleIf().Printf( infoNum++, KTEST_NAME, KSourceFileError); |
|
612 iLog->Log((TDesC)KSourceFileError); |
|
613 } |
|
614 |
|
615 } |
|
616 |
|
617 CleanupStack::PopAndDestroy(&fs); |
|
618 |
|
619 if ( nResult == KErrNone) |
|
620 { |
|
621 TestModuleIf().Printf( infoNum++, KTEST_NAME,KComparePassed); |
|
622 iLog->Log((TDesC)KComparePassed); |
|
623 } |
|
624 else |
|
625 { |
|
626 TestModuleIf().Printf( infoNum++, KTEST_NAME, KCompareFailed); |
|
627 iLog->Log((TDesC)KCompareFailed); |
|
628 } |
|
629 |
|
630 return nResult; |
|
631 } |