1 // Licensed to the .NET Foundation under one or more agreements.
2 // The .NET Foundation licenses this file to you under the MIT license.
3 // See the LICENSE file in the project root for more information.
4 
5 using Microsoft.Test.ModuleCore;
6 using System;
7 using System.Xml;
8 
9 namespace CoreXml.Test.XLinq
10 {
11     public partial class FunctionalTests : TestModule
12     {
13 
14         public partial class XNodeReaderTests : XLinqTestCase
15         {
16             public enum EINTEGRITY
17             {
18                 //DataReader
19                 BEFORE_READ,
20                 AFTER_READ_FALSE,
21                 AFTER_RESETSTATE,
22 
23                 //DataWriter
24                 BEFORE_WRITE,
25                 AFTER_WRITE_FALSE,
26                 AFTER_CLEAR,
27                 AFTER_FLUSH,
28 
29                 // Both DataWriter and DataReader
30                 AFTER_CLOSE,
31                 CLOSE_IN_THE_MIDDLE,
32             }
33 
34             //[TestCase(Name = "XMLIntegrityBase", Desc = "XMLIntegrityBase")]
35             public partial class TCXMLIntegrityBase : BridgeHelpers
36             {
37                 private EINTEGRITY _eEIntegrity;
38 
39                 public EINTEGRITY IntegrityVer
40                 {
41                     get { return _eEIntegrity; }
42                     set { _eEIntegrity = value; }
43                 }
44 
45                 public static string pATTR = "Attr1";
46                 public static string pNS = "Foo";
47                 public static string pNAME = "PLAY0";
48 
ReloadSource()49                 public XmlReader ReloadSource()
50                 {
51                     string strFile = GetTestFileName();
52                     XmlReader DataReader = GetReader(strFile);
53                     InitReaderPointer(DataReader);
54                     return DataReader;
55                 }
56 
InitReaderPointer(XmlReader DataReader)57                 public void InitReaderPointer(XmlReader DataReader)
58                 {
59                     if (this.Desc == "BeforeRead")
60                     {
61                         IntegrityVer = EINTEGRITY.BEFORE_READ;
62                         TestLog.Compare(DataReader.ReadState, ReadState.Initial, "ReadState=Initial");
63                         TestLog.Compare(DataReader.EOF, false, "EOF==false");
64                     }
65                     else if (this.Desc == "AfterReadIsFalse")
66                     {
67                         IntegrityVer = EINTEGRITY.AFTER_READ_FALSE;
68                         while (DataReader.Read()) ;
69                         TestLog.Compare(DataReader.ReadState, ReadState.EndOfFile, "ReadState=EOF");
70                         TestLog.Compare(DataReader.EOF, true, "EOF==true");
71                     }
72                     else if (this.Desc == "AfterClose")
73                     {
74                         IntegrityVer = EINTEGRITY.AFTER_CLOSE;
75                         while (DataReader.Read()) ;
76                         DataReader.Dispose();
77                         TestLog.Compare(DataReader.ReadState, ReadState.Closed, "ReadState=Closed");
78                         TestLog.Compare(DataReader.EOF, false, "EOF==true");
79                     }
80                     else if (this.Desc == "AfterCloseInTheMiddle")
81                     {
82                         IntegrityVer = EINTEGRITY.CLOSE_IN_THE_MIDDLE;
83                         for (int i = 0; i < 1; i++)
84                         {
85                             if (false == DataReader.Read())
86                                 throw new TestFailedException("");
87                             TestLog.Compare(DataReader.ReadState, ReadState.Interactive, "ReadState=Interactive");
88                         }
89                         DataReader.Dispose();
90                         TestLog.Compare(DataReader.ReadState, ReadState.Closed, "ReadState=Closed");
91                         TestLog.Compare(DataReader.EOF, false, "EOF==true");
92                     }
93                     else if (this.Desc == "AfterResetState")
94                     {
95                         IntegrityVer = EINTEGRITY.AFTER_RESETSTATE;
96                         // position the reader somewhere in the middle of the file
97                         PositionOnElement(DataReader, "elem1");
98                         TestLog.Compare(DataReader.ReadState, ReadState.Initial, "ReadState=Initial");
99                     }
100                 }
101 
102                 //[Variation("NodeType")]
GetXmlReaderNodeType()103                 public void GetXmlReaderNodeType()
104                 {
105                     XmlReader DataReader = ReloadSource();
106                     TestLog.Compare(DataReader.NodeType, XmlNodeType.None, Variation.Desc);
107                     TestLog.Compare(DataReader.NodeType, XmlNodeType.None, Variation.Desc);
108                 }
109 
110                 //[Variation("Name")]
GetXmlReaderName()111                 public void GetXmlReaderName()
112                 {
113                     XmlReader DataReader = ReloadSource();
114                     TestLog.Compare(DataReader.Name, String.Empty, Variation.Desc);
115                     TestLog.Compare(DataReader.Name, String.Empty, Variation.Desc);
116                 }
117 
118                 //[Variation("LocalName")]
GetXmlReaderLocalName()119                 public void GetXmlReaderLocalName()
120                 {
121                     XmlReader DataReader = ReloadSource();
122                     TestLog.Compare(DataReader.LocalName, String.Empty, Variation.Desc);
123                     TestLog.Compare(DataReader.LocalName, String.Empty, Variation.Desc);
124                 }
125 
126                 //[Variation("NamespaceURI")]
Namespace()127                 public void Namespace()
128                 {
129                     XmlReader DataReader = ReloadSource();
130                     TestLog.Compare(DataReader.NamespaceURI, String.Empty, Variation.Desc);
131                     TestLog.Compare(DataReader.NamespaceURI, String.Empty, Variation.Desc);
132                 }
133 
134                 //[Variation("Prefix")]
Prefix()135                 public void Prefix()
136                 {
137                     XmlReader DataReader = ReloadSource();
138                     TestLog.Compare(DataReader.Prefix, String.Empty, Variation.Desc);
139                     TestLog.Compare(DataReader.Prefix, String.Empty, Variation.Desc);
140                 }
141 
142                 //[Variation("HasValue")]
HasValue()143                 public void HasValue()
144                 {
145                     XmlReader DataReader = ReloadSource();
146                     TestLog.Compare(DataReader.HasValue, false, Variation.Desc);
147                     TestLog.Compare(DataReader.HasValue, false, Variation.Desc);
148                 }
149 
150                 //[Variation("Value")]
GetXmlReaderValue()151                 public void GetXmlReaderValue()
152                 {
153                     XmlReader DataReader = ReloadSource();
154                     TestLog.Compare(DataReader.Value, String.Empty, Variation.Desc);
155                     TestLog.Compare(DataReader.Value, String.Empty, Variation.Desc);
156                 }
157 
158                 //[Variation("Depth")]
GetDepth()159                 public void GetDepth()
160                 {
161                     XmlReader DataReader = ReloadSource();
162                     TestLog.Compare(DataReader.Depth, 0, Variation.Desc);
163                     TestLog.Compare(DataReader.Depth, 0, Variation.Desc);
164                 }
165 
166                 //[Variation("BaseURI")]
GetBaseURI()167                 public void GetBaseURI()
168                 {
169                     XmlReader DataReader = ReloadSource();
170                     TestLog.Compare(DataReader.BaseURI, String.Empty, Variation.Desc);
171                     TestLog.Compare(DataReader.BaseURI, String.Empty, Variation.Desc);
172                 }
173 
174                 //[Variation("IsEmptyElement")]
IsEmptyElement()175                 public void IsEmptyElement()
176                 {
177                     XmlReader DataReader = ReloadSource();
178                     TestLog.Compare(DataReader.IsEmptyElement, false, Variation.Desc);
179                     TestLog.Compare(DataReader.IsEmptyElement, false, Variation.Desc);
180                 }
181 
182                 //[Variation("IsDefault")]
IsDefault()183                 public void IsDefault()
184                 {
185                     XmlReader DataReader = ReloadSource();
186                     TestLog.Compare(DataReader.IsDefault, false, Variation.Desc);
187                     TestLog.Compare(DataReader.IsDefault, false, Variation.Desc);
188                 }
189 
190                 //[Variation("XmlSpace")]
GetXmlSpace()191                 public void GetXmlSpace()
192                 {
193                     XmlReader DataReader = ReloadSource();
194                     TestLog.Compare(DataReader.XmlSpace, XmlSpace.None, Variation.Desc);
195                     TestLog.Compare(DataReader.XmlSpace, XmlSpace.None, Variation.Desc);
196                 }
197 
198                 //[Variation("XmlLang")]
GetXmlLang()199                 public void GetXmlLang()
200                 {
201                     XmlReader DataReader = ReloadSource();
202                     TestLog.Compare(DataReader.XmlLang, String.Empty, Variation.Desc);
203                     TestLog.Compare(DataReader.XmlLang, String.Empty, Variation.Desc);
204                 }
205 
206                 //[Variation("AttributeCount")]
AttributeCount()207                 public void AttributeCount()
208                 {
209                     XmlReader DataReader = ReloadSource();
210                     TestLog.Compare(DataReader.AttributeCount, 0, Variation.Desc);
211                     TestLog.Compare(DataReader.AttributeCount, 0, Variation.Desc);
212                 }
213 
214                 //[Variation("HasAttributes")]
HasAttribute()215                 public void HasAttribute()
216                 {
217                     XmlReader DataReader = ReloadSource();
218                     TestLog.Compare(DataReader.HasAttributes, false, Variation.Desc);
219                     TestLog.Compare(DataReader.HasAttributes, false, Variation.Desc);
220                 }
221 
222                 //[Variation("GetAttributes(name)")]
GetAttributeName()223                 public void GetAttributeName()
224                 {
225                     XmlReader DataReader = ReloadSource();
226                     TestLog.Compare(DataReader.GetAttribute(pATTR), null, "Compare the GetAttribute");
227                 }
228 
229                 //[Variation("GetAttribute(String.Empty)")]
GetAttributeEmptyName()230                 public void GetAttributeEmptyName()
231                 {
232                     XmlReader DataReader = ReloadSource();
233                     TestLog.Compare(DataReader.GetAttribute(String.Empty), null, "Compare the GetAttribute");
234                 }
235 
236                 //[Variation("GetAttribute(name,ns)")]
GetAttributeNameNamespace()237                 public void GetAttributeNameNamespace()
238                 {
239                     XmlReader DataReader = ReloadSource();
240                     TestLog.Compare(DataReader.GetAttribute(pATTR, pNS), null, "Compare the GetAttribute");
241                 }
242 
243                 //[Variation("GetAttribute(String.Empty, String.Empty)")]
GetAttributeEmptyNameNamespace()244                 public void GetAttributeEmptyNameNamespace()
245                 {
246                     XmlReader DataReader = ReloadSource();
247                     TestLog.Compare(DataReader.GetAttribute(String.Empty, String.Empty), null, "Compare the GetAttribute");
248                 }
249 
250                 //[Variation("GetAttribute(i)")]
GetAttributeOrdinal()251                 public void GetAttributeOrdinal()
252                 {
253                     XmlReader DataReader = ReloadSource();
254                     DataReader.GetAttribute(0);
255                 }
256 
257                 //[Variation("this[i]")]
HelperThisOrdinal()258                 public void HelperThisOrdinal()
259                 {
260                     XmlReader DataReader = ReloadSource();
261                     string str = DataReader[0];
262                 }
263 
264                 //[Variation("this[name]")]
HelperThisName()265                 public void HelperThisName()
266                 {
267                     XmlReader DataReader = ReloadSource();
268                     TestLog.Compare(DataReader[pATTR], null, "Compare the GetAttribute");
269                 }
270 
271                 //[Variation("this[name,namespace]")]
HelperThisNameNamespace()272                 public void HelperThisNameNamespace()
273                 {
274                     XmlReader DataReader = ReloadSource();
275                     string str = DataReader[pATTR, pNS];
276                     TestLog.Compare(DataReader[pATTR, pNS], null, "Compare the GetAttribute");
277                 }
278 
279                 //[Variation("MoveToAttribute(name)")]
MoveToAttributeName()280                 public void MoveToAttributeName()
281                 {
282                     XmlReader DataReader = ReloadSource();
283                     TestLog.Compare(DataReader.MoveToAttribute(pATTR), false, Variation.Desc);
284                     TestLog.Compare(DataReader.MoveToAttribute(pATTR), false, Variation.Desc);
285                 }
286 
287                 //[Variation("MoveToAttributeNameNamespace(name,ns)")]
MoveToAttributeNameNamespace()288                 public void MoveToAttributeNameNamespace()
289                 {
290                     XmlReader DataReader = ReloadSource();
291                     TestLog.Compare(DataReader.MoveToAttribute(pATTR, pNS), false, Variation.Desc);
292                     TestLog.Compare(DataReader.MoveToAttribute(pATTR, pNS), false, Variation.Desc);
293                 }
294 
295                 //[Variation("MoveToAttribute(i)")]
MoveToAttributeOrdinal()296                 public void MoveToAttributeOrdinal()
297                 {
298                     XmlReader DataReader = ReloadSource();
299                     DataReader.MoveToAttribute(0);
300                 }
301 
302                 //[Variation("MoveToFirstAttribute()")]
MoveToFirstAttribute()303                 public void MoveToFirstAttribute()
304                 {
305                     XmlReader DataReader = ReloadSource();
306                     TestLog.Compare(DataReader.MoveToFirstAttribute(), false, Variation.Desc);
307                     TestLog.Compare(DataReader.MoveToFirstAttribute(), false, Variation.Desc);
308                 }
309 
310                 //[Variation("MoveToNextAttribute()")]
MoveToNextAttribute()311                 public void MoveToNextAttribute()
312                 {
313                     XmlReader DataReader = ReloadSource();
314                     TestLog.Compare(DataReader.MoveToNextAttribute(), false, Variation.Desc);
315                     TestLog.Compare(DataReader.MoveToNextAttribute(), false, Variation.Desc);
316                 }
317 
318                 //[Variation("MoveToElement()")]
MoveToElement()319                 public void MoveToElement()
320                 {
321                     XmlReader DataReader = ReloadSource();
322                     TestLog.Compare(DataReader.MoveToElement(), false, Variation.Desc);
323                     TestLog.Compare(DataReader.MoveToElement(), false, Variation.Desc);
324                 }
325 
326                 //[Variation("Read")]
ReadTestAfterClose()327                 public void ReadTestAfterClose()
328                 {
329                     XmlReader DataReader = ReloadSource();
330                     TestLog.Compare(DataReader.Read(), true, Variation.Desc);
331                     TestLog.Compare(DataReader.Read(), true, Variation.Desc);
332                 }
333 
334                 //[Variation("GetEOF")]
GetEOF()335                 public void GetEOF()
336                 {
337                     XmlReader DataReader = ReloadSource();
338                     if ((IntegrityVer == EINTEGRITY.AFTER_READ_FALSE))
339                     {
340                         TestLog.Compare(DataReader.EOF, true, Variation.Desc);
341                         TestLog.Compare(DataReader.EOF, true, Variation.Desc);
342                     }
343                     else
344                     {
345                         TestLog.Compare(DataReader.EOF, false, Variation.Desc);
346                         TestLog.Compare(DataReader.EOF, false, Variation.Desc);
347                     }
348                 }
349 
350                 //[Variation("GetReadState")]
GetReadState()351                 public void GetReadState()
352                 {
353                     XmlReader DataReader = ReloadSource();
354                     ReadState iState = ReadState.Initial;
355 
356                     // EndOfFile State
357                     if ((IntegrityVer == EINTEGRITY.AFTER_READ_FALSE))
358                     {
359                         iState = ReadState.EndOfFile;
360                     }
361 
362                     // Closed State
363                     if ((IntegrityVer == EINTEGRITY.AFTER_CLOSE) || (IntegrityVer == EINTEGRITY.CLOSE_IN_THE_MIDDLE))
364                     {
365                         iState = ReadState.Closed;
366                     }
367                     TestLog.Compare(DataReader.ReadState, iState, Variation.Desc);
368                     TestLog.Compare(DataReader.ReadState, iState, Variation.Desc);
369                 }
370 
371                 //[Variation("Skip")]
XMLSkip()372                 public void XMLSkip()
373                 {
374                     XmlReader DataReader = ReloadSource();
375                     DataReader.Skip();
376                     DataReader.Skip();
377                 }
378 
379                 //[Variation("NameTable")]
TestNameTable()380                 public void TestNameTable()
381                 {
382                     XmlReader DataReader = ReloadSource();
383                     TestLog.Compare(DataReader.NameTable != null, "nt");
384                 }
385 
386                 //[Variation("ReadInnerXml")]
ReadInnerXmlTestAfterClose()387                 public void ReadInnerXmlTestAfterClose()
388                 {
389                     XmlReader DataReader = ReloadSource();
390                     XmlNodeType nt = DataReader.NodeType;
391                     string name = DataReader.Name;
392                     string value = DataReader.Value;
393                     TestLog.Compare(DataReader.ReadInnerXml(), String.Empty, Variation.Desc);
394                     TestLog.Compare(VerifyNode(DataReader, nt, name, value), "vn");
395                 }
396 
397                 //[Variation("ReadOuterXml")]
TestReadOuterXml()398                 public void TestReadOuterXml()
399                 {
400                     XmlReader DataReader = ReloadSource();
401                     XmlNodeType nt = DataReader.NodeType;
402                     string name = DataReader.Name;
403                     string value = DataReader.Value;
404                     TestLog.Compare(DataReader.ReadOuterXml(), String.Empty, Variation.Desc);
405                     TestLog.Compare(VerifyNode(DataReader, nt, name, value), "vn");
406                 }
407 
408                 //[Variation("MoveToContent")]
TestMoveToContent()409                 public void TestMoveToContent()
410                 {
411                     XmlReader DataReader = ReloadSource();
412                     TestLog.Compare(DataReader.MoveToContent(), XmlNodeType.Element, Variation.Desc);
413                 }
414 
415                 //[Variation("IsStartElement")]
TestIsStartElement()416                 public void TestIsStartElement()
417                 {
418                     XmlReader DataReader = ReloadSource();
419                     TestLog.Compare(DataReader.IsStartElement(), true, Variation.Desc);
420                 }
421 
422                 //[Variation("IsStartElement(name)")]
TestIsStartElementName()423                 public void TestIsStartElementName()
424                 {
425                     XmlReader DataReader = ReloadSource();
426                     TestLog.Compare(DataReader.IsStartElement(pNAME), false, Variation.Desc);
427                 }
428 
429                 //[Variation("IsStartElement(String.Empty)")]
TestIsStartElementName2()430                 public void TestIsStartElementName2()
431                 {
432                     XmlReader DataReader = ReloadSource();
433                     TestLog.Compare(DataReader.IsStartElement(String.Empty), false, Variation.Desc);
434                 }
435 
436                 //[Variation("IsStartElement(name, ns)")]
TestIsStartElementNameNs()437                 public void TestIsStartElementNameNs()
438                 {
439                     XmlReader DataReader = ReloadSource();
440                     TestLog.Compare(DataReader.IsStartElement(pNAME, pNS), false, Variation.Desc);
441                 }
442 
443                 //[Variation("IsStartElement(String.Empty,String.Empty)")]
TestIsStartElementNameNs2()444                 public void TestIsStartElementNameNs2()
445                 {
446                     XmlReader DataReader = ReloadSource();
447                     TestLog.Compare(DataReader.IsStartElement(String.Empty, String.Empty), false, Variation.Desc);
448                 }
449 
450                 //[Variation("ReadStartElement")]
TestReadStartElement()451                 public void TestReadStartElement()
452                 {
453                     XmlReader DataReader = ReloadSource();
454                     DataReader.ReadStartElement();
455                 }
456 
457                 //[Variation("ReadStartElement(name)")]
TestReadStartElementName()458                 public void TestReadStartElementName()
459                 {
460                     XmlReader DataReader = ReloadSource();
461                     try
462                     {
463                         DataReader.ReadStartElement(pNAME);
464                     }
465                     catch (XmlException)
466                     {
467                         return;
468                     }
469                     throw new TestException(TestResult.Failed, "");
470                 }
471 
472                 //[Variation("ReadStartElement(String.Empty)")]
TestReadStartElementName2()473                 public void TestReadStartElementName2()
474                 {
475                     XmlReader DataReader = ReloadSource();
476                     try
477                     {
478                         DataReader.ReadStartElement(String.Empty);
479                     }
480                     catch (XmlException)
481                     {
482                         return;
483                     }
484                     throw new TestException(TestResult.Failed, "");
485                 }
486 
487                 //[Variation("ReadStartElement(name, ns)")]
TestReadStartElementNameNs()488                 public void TestReadStartElementNameNs()
489                 {
490                     XmlReader DataReader = ReloadSource();
491                     try
492                     {
493                         DataReader.ReadStartElement(pNAME, pNS);
494                     }
495                     catch (XmlException)
496                     {
497                         return;
498                     }
499                     throw new TestException(TestResult.Failed, "");
500                 }
501 
502                 //[Variation("ReadStartElement(String.Empty,String.Empty)")]
TestReadStartElementNameNs2()503                 public void TestReadStartElementNameNs2()
504                 {
505                     XmlReader DataReader = ReloadSource();
506                     try
507                     {
508                         DataReader.ReadStartElement(String.Empty, String.Empty);
509                     }
510                     catch (XmlException)
511                     {
512                         return;
513                     }
514                     throw new TestException(TestResult.Failed, "");
515                 }
516 
517                 //[Variation("ReadEndElement")]
TestReadEndElement()518                 public void TestReadEndElement()
519                 {
520                     XmlReader DataReader = ReloadSource();
521                     try
522                     {
523                         DataReader.ReadEndElement();
524                     }
525                     catch (XmlException)
526                     {
527                         return;
528                     }
529                     throw new TestException(TestResult.Failed, "");
530                 }
531 
532                 //[Variation("LookupNamespace")]
LookupNamespace()533                 public void LookupNamespace()
534                 {
535                     XmlReader DataReader = ReloadSource();
536                     string[] astr = { "a", "Foo", String.Empty, "Foo1", "Foo_S" };
537 
538                     for (int i = 0; i < astr.Length; i++)
539                     {
540                         if (DataReader.LookupNamespace(astr[i]) != null)
541                         {
542                         }
543                         TestLog.Compare(DataReader.LookupNamespace(astr[i]), null, Variation.Desc);
544                     }
545                 }
546 
547                 //[Variation("ReadAttributeValue")]
ReadAttributeValue()548                 public void ReadAttributeValue()
549                 {
550                     XmlReader DataReader = ReloadSource();
551                     TestLog.Compare(DataReader.ReadAttributeValue(), false, Variation.Desc);
552                     TestLog.Compare(DataReader.ReadAttributeValue(), false, Variation.Desc);
553                 }
554 
555                 //[Variation("Close")]
CloseTest()556                 public void CloseTest()
557                 {
558                     XmlReader DataReader = ReloadSource();
559                     DataReader.Dispose();
560                     DataReader.Dispose();
561                     DataReader.Dispose();
562                 }
563             }
564         }
565     }
566 }
567