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 System;
6 using System.IO;
7 using System.Xml;
8 using Microsoft.Test.ModuleCore;
9 
10 namespace CoreXml.Test.XLinq
11 {
12     public partial class FunctionalTests : TestModule
13     {
14         public partial class XNodeReaderTests : XLinqTestCase
15         {
16             public partial class TCDepth : BridgeHelpers
17             {
18                 //[Variation("XmlReader Depth at the Root", Priority = 0)]
TestDepth1()19                 public void TestDepth1()
20                 {
21                     XmlReader DataReader = GetReader();
22                     int iDepth = 0;
23                     PositionOnElement(DataReader, "PLAY");
24                     TestLog.Compare(DataReader.Depth, iDepth, "Depth should be " + iDepth);
25                     DataReader.Dispose();
26                 }
27 
28                 //[Variation("XmlReader Depth at Empty Tag")]
TestDepth2()29                 public void TestDepth2()
30                 {
31                     XmlReader DataReader = GetReader();
32                     int iDepth = 2;
33                     PositionOnElement(DataReader, "EMPTY1");
34                     TestLog.Compare(DataReader.Depth, iDepth, "Depth should be " + iDepth);
35                 }
36 
37                 //[Variation("XmlReader Depth at Empty Tag with Attributes")]
TestDepth3()38                 public void TestDepth3()
39                 {
40                     XmlReader DataReader = GetReader();
41                     int iDepth = 2;
42                     PositionOnElement(DataReader, "ACT1");
43                     TestLog.Compare(DataReader.Depth, iDepth, "Element Depth should be " + (iDepth).ToString());
44                     while (DataReader.MoveToNextAttribute() == true)
45                     {
46                         TestLog.Compare(DataReader.Depth, iDepth + 1, "Attr Depth should be " + (iDepth + 1).ToString());
47                     }
48                 }
49 
50                 //[Variation("XmlReader Depth at Non Empty Tag with Text")]
TestDepth4()51                 public void TestDepth4()
52                 {
53                     XmlReader DataReader = GetReader();
54                     int iDepth = 2;
55                     PositionOnElement(DataReader, "NONEMPTY1");
56                     TestLog.Compare(DataReader.Depth, iDepth, "Depth should be " + iDepth);
57                     while (true == DataReader.Read())
58                     {
59                         if (DataReader.NodeType == XmlNodeType.Text)
60                             TestLog.Compare(DataReader.Depth, iDepth + 1, "Depth should be " + (iDepth + 1).ToString());
61 
62                         if (DataReader.Name == "NONEMPTY1" && (DataReader.NodeType == XmlNodeType.EndElement)) break;
63                     }
64                     TestLog.Compare(DataReader.Depth, iDepth, "Depth should be " + iDepth);
65                 }
66             }
67 
68             public partial class TCNamespace : BridgeHelpers
69             {
70                 public static string pNONAMESPACE = "NONAMESPACE";
71 
72                 //[Variation("Namespace test within a scope (no nested element)", Priority = 0)]
TestNamespace1()73                 public void TestNamespace1()
74                 {
75                     XmlReader DataReader = GetReader();
76                     PositionOnElement(DataReader, "NAMESPACE0");
77 
78                     while (true == DataReader.Read())
79                     {
80                         if (DataReader.Name == "NAMESPACE1") break;
81 
82                         if (DataReader.NodeType == XmlNodeType.Element)
83                         {
84                             TestLog.Compare(DataReader.NamespaceURI, "1", "Compare Namespace");
85                             TestLog.Compare(DataReader.Name, "bar:check", "Compare Name");
86                             TestLog.Compare(DataReader.LocalName, "check", "Compare LocalName");
87                             TestLog.Compare(DataReader.Prefix, "bar", "Compare Prefix");
88                         }
89                     }
90                 }
91 
92                 //[Variation("Namespace test within a scope (with nested element)", Priority = 0)]
TestNamespace2()93                 public void TestNamespace2()
94                 {
95                     XmlReader DataReader = GetReader();
96 
97                     PositionOnElement(DataReader, "NAMESPACE1");
98                     while (true == DataReader.Read())
99                     {
100                         if (DataReader.Name == "NONAMESPACE") break;
101                         if ((DataReader.NodeType == XmlNodeType.Element) && (DataReader.LocalName == "check"))
102                         {
103                             TestLog.Compare(DataReader.NamespaceURI, "1", "Compare Namespace");
104                             TestLog.Compare(DataReader.Name, "bar:check", "Compare Name");
105                             TestLog.Compare(DataReader.LocalName, "check", "Compare LocalName");
106                             TestLog.Compare(DataReader.Prefix, "bar", "Compare Prefix");
107                         }
108                     }
109                     TestLog.Compare(DataReader.NamespaceURI, String.Empty, "Compare Namespace with String.Empty");
110                 }
111 
112                 //[Variation("Namespace test immediately outside the Namespace scope")]
TestNamespace3()113                 public void TestNamespace3()
114                 {
115                     XmlReader DataReader = GetReader();
116 
117                     PositionOnElement(DataReader, pNONAMESPACE);
118                     TestLog.Compare(DataReader.NamespaceURI, String.Empty, "Compare Namespace with EmptyString");
119                     TestLog.Compare(DataReader.Name, pNONAMESPACE, "Compare Name");
120                     TestLog.Compare(DataReader.LocalName, pNONAMESPACE, "Compare LocalName");
121                     TestLog.Compare(DataReader.Prefix, String.Empty, "Compare Prefix");
122                 }
123 
124                 //[Variation("Namespace test Attribute should has no default namespace", Priority = 0)]
TestNamespace4()125                 public void TestNamespace4()
126                 {
127                     XmlReader DataReader = GetReader();
128                     PositionOnElement(DataReader, "NONAMESPACE1");
129                     TestLog.Compare(DataReader.NamespaceURI, "1000", "Compare Namespace for Element");
130                     if (DataReader.MoveToFirstAttribute())
131                     {
132                         TestLog.Compare(DataReader.NamespaceURI, String.Empty, "Compare Namespace for Attr");
133                     }
134                 }
135 
136                 //[Variation("Namespace test with multiple Namespace declaration", Priority = 0)]
TestNamespace5()137                 public void TestNamespace5()
138                 {
139                     XmlReader DataReader = GetReader();
140 
141                     PositionOnElement(DataReader, "NAMESPACE2");
142                     while (true == DataReader.Read())
143                     {
144                         if (DataReader.Name == "NAMESPACE3") break;
145                         if ((DataReader.NodeType == XmlNodeType.Element) && (DataReader.LocalName == "check"))
146                         {
147                             TestLog.Compare(DataReader.NamespaceURI, "2", "Compare Namespace");
148                             TestLog.Compare(DataReader.Name, "bar:check", "Compare Name");
149                             TestLog.Compare(DataReader.LocalName, "check", "Compare LocalName");
150                             TestLog.Compare(DataReader.Prefix, "bar", "Compare Prefix");
151                         }
152                     }
153                 }
154 
155                 //[Variation("Namespace test with multiple Namespace declaration, including default namespace")]
TestNamespace6()156                 public void TestNamespace6()
157                 {
158                     XmlReader DataReader = GetReader();
159 
160                     PositionOnElement(DataReader, "NAMESPACE3");
161                     while (true == DataReader.Read())
162                     {
163                         if (DataReader.Name == "NONAMESPACE") break;
164 
165                         if (DataReader.NodeType == XmlNodeType.Element)
166                         {
167                             if (DataReader.LocalName == "check")
168                             {
169                                 TestLog.Compare(DataReader.NamespaceURI, "1", "Compare Namespace");
170                                 TestLog.Compare(DataReader.Name, "check", "Compare Name");
171                                 TestLog.Compare(DataReader.LocalName, "check", "Compare LocalName");
172                                 TestLog.Compare(DataReader.Prefix, String.Empty, "Compare Prefix");
173                             }
174                             else if (DataReader.LocalName == "check1")
175                             {
176                                 TestLog.Compare(DataReader.NamespaceURI, "1", "Compare Namespace");
177                                 TestLog.Compare(DataReader.Name, "check1", "Compare Name");
178                                 TestLog.Compare(DataReader.LocalName, "check1", "Compare LocalName");
179                                 TestLog.Compare(DataReader.Prefix, String.Empty, "Compare Prefix");
180                             }
181                             else if (DataReader.LocalName == "check8")
182                             {
183                                 TestLog.Compare(DataReader.NamespaceURI, "8", "Compare Namespace");
184                                 TestLog.Compare(DataReader.Name, "d:check8", "Compare Name");
185                                 TestLog.Compare(DataReader.LocalName, "check8", "Compare LocalName");
186                                 TestLog.Compare(DataReader.Prefix, "d", "Compare Prefix");
187                             }
188                             else if (DataReader.LocalName == "check100")
189                             {
190                                 TestLog.Compare(DataReader.NamespaceURI, "100", "Compare Namespace");
191                                 TestLog.Compare(DataReader.Name, "check100", "Compare Name");
192                                 TestLog.Compare(DataReader.LocalName, "check100", "Compare LocalName");
193                                 TestLog.Compare(DataReader.Prefix, String.Empty, "Compare Prefix");
194                             }
195                             else if (DataReader.LocalName == "check5")
196                             {
197                                 TestLog.Compare(DataReader.NamespaceURI, "5", "Compare Namespace");
198                                 TestLog.Compare(DataReader.Name, "d:check5", "Compare Name");
199                                 TestLog.Compare(DataReader.LocalName, "check5", "Compare LocalName");
200                                 TestLog.Compare(DataReader.Prefix, "d", "Compare Prefix");
201                             }
202                             else if (DataReader.LocalName == "check14")
203                             {
204                                 TestLog.Compare(DataReader.NamespaceURI, "14", "Compare Namespace");
205                                 TestLog.Compare(DataReader.Name, "check14", "Compare Name");
206                                 TestLog.Compare(DataReader.LocalName, "check14", "Compare LocalName");
207                                 TestLog.Compare(DataReader.Prefix, String.Empty, "Compare Prefix");
208                             }
209                             else if (DataReader.LocalName == "a13")
210                             {
211                                 TestLog.Compare(DataReader.NamespaceURI, "1", "Compare Namespace1");
212                                 TestLog.Compare(DataReader.Name, "a13", "Compare Name1");
213                                 TestLog.Compare(DataReader.LocalName, "a13", "Compare LocalName1");
214                                 TestLog.Compare(DataReader.Prefix, String.Empty, "Compare Prefix1");
215                                 DataReader.MoveToFirstAttribute();
216                                 TestLog.Compare(DataReader.NamespaceURI, "13", "Compare Namespace2");
217                                 TestLog.Compare(DataReader.Name, "a:check", "Compare Name2");
218                                 TestLog.Compare(DataReader.LocalName, "check", "Compare LocalName2");
219                                 TestLog.Compare(DataReader.Prefix, "a", "Compare Prefix2");
220                                 TestLog.Compare(DataReader.Value, "Namespace=13", "Compare Name2");
221                             }
222                         }
223                     }
224                 }
225 
226                 //[Variation("Namespace URI for xml prefix", Priority = 0)]
TestNamespace7()227                 public void TestNamespace7()
228                 {
229                     string strxml = "<ROOT xml:space='preserve'/>";
230                     XmlReader DataReader = GetReader(new StringReader(strxml));
231                     PositionOnElement(DataReader, "ROOT");
232                     DataReader.MoveToFirstAttribute();
233                     TestLog.Compare(DataReader.NamespaceURI, "http://www.w3.org/XML/1998/namespace", "xml");
234                 }
235             }
236 
237             public partial class TCLookupNamespace : BridgeHelpers
238             {
239                 //[Variation("LookupNamespace test within EmptyTag")]
LookupNamespace1()240                 public void LookupNamespace1()
241                 {
242                     XmlReader DataReader = GetReader();
243                     PositionOnElement(DataReader, "EMPTY_NAMESPACE");
244                     do
245                     {
246                         TestLog.Compare(DataReader.LookupNamespace("bar"), "1", "Compare LookupNamespace");
247                     } while (DataReader.MoveToNextAttribute() == true);
248                 }
249 
250                 //[Variation("LookupNamespace test with Default namespace within EmptyTag", Priority = 0)]
LookupNamespace2()251                 public void LookupNamespace2()
252                 {
253                     XmlReader DataReader = GetReader();
254                     PositionOnElement(DataReader, "EMPTY_NAMESPACE1");
255                     do
256                     {
257                         TestLog.Compare(DataReader.LookupNamespace(String.Empty), "14", "Compare LookupNamespace");
258                     } while (DataReader.MoveToNextAttribute() == true);
259                 }
260 
261                 //[Variation("LookupNamespace test within a scope (no nested element)", Priority = 0)]
LookupNamespace3()262                 public void LookupNamespace3()
263                 {
264                     XmlReader DataReader = GetReader();
265                     while (true == DataReader.Read())
266                     {
267                         if (DataReader.Name == "NAMESPACE0") break;
268                         TestLog.Compare(DataReader.LookupNamespace("bar"), null, "Compare LookupNamespace");
269                     }
270 
271                     while (true == DataReader.Read())
272                     {
273                         TestLog.Compare(DataReader.LookupNamespace("bar"), "1", "Compare LookupNamespace");
274                         if (DataReader.Name == "NAMESPACE0" && DataReader.NodeType == XmlNodeType.EndElement) break;
275                     }
276                 }
277 
278                 //[Variation("LookupNamespace test within a scope (with nested element)", Priority = 0)]
LookupNamespace4()279                 public void LookupNamespace4()
280                 {
281                     XmlReader DataReader = GetReader();
282                     PositionOnElement(DataReader, "NAMESPACE1");
283                     while (true == DataReader.Read())
284                     {
285                         TestLog.Compare(DataReader.LookupNamespace("bar"), "1", "Compare LookupNamespace");
286                         if (DataReader.Name == "NAMESPACE1" && DataReader.NodeType == XmlNodeType.EndElement)
287                         {
288                             DataReader.Read();
289                             break;
290                         }
291                     }
292                     TestLog.Compare(DataReader.LookupNamespace("bar"), null, "Compare LookupNamespace with String.Empty");
293                 }
294 
295                 //[Variation("LookupNamespace test immediately outside the Namespace scope")]
LookupNamespace5()296                 public void LookupNamespace5()
297                 {
298                     XmlReader DataReader = GetReader();
299                     PositionOnElement(DataReader, "NONAMESPACE");
300                     TestLog.Compare(DataReader.LookupNamespace("bar"), null, "Compare LookupNamespace with null");
301                 }
302 
303                 //[Variation("LookupNamespace test with multiple Namespace declaration", Priority = 0)]
LookupNamespace6()304                 public void LookupNamespace6()
305                 {
306                     XmlReader DataReader = GetReader();
307                     PositionOnElement(DataReader, "NAMESPACE2");
308 
309                     string strValue = "1";
310                     while (true == DataReader.Read())
311                     {
312                         if (DataReader.Name == "c")
313                         {
314                             strValue = "2";
315                             TestLog.Compare(DataReader.LookupNamespace("bar"), strValue, "Compare LookupNamespace-a");
316                             if (DataReader.NodeType == XmlNodeType.EndElement)
317                                 strValue = "1";
318                         }
319                         else
320                             TestLog.Compare(DataReader.LookupNamespace("bar"), strValue, "Compare LookupNamespace-a");
321 
322                         if (DataReader.Name == "NAMESPACE2" && DataReader.NodeType == XmlNodeType.EndElement)
323                         {
324                             TestLog.Compare(DataReader.LookupNamespace("bar"), strValue, "Compare LookupNamespace-a");
325                             DataReader.Read();
326                             break;
327                         }
328                     }
329                 }
330 
CompareAllNS(XmlReader DataReader, string strDef, string strA, string strB, string strC, string strD, string strE, string strF, string strG, string strH)331                 void CompareAllNS(XmlReader DataReader, string strDef, string strA, string strB, string strC, string strD, string strE, string strF, string strG, string strH)
332                 {
333                     TestLog.Compare(DataReader.LookupNamespace(String.Empty), strDef, "Compare LookupNamespace-default");
334                     TestLog.Compare(DataReader.LookupNamespace("a"), strA, "Compare LookupNamespace-a");
335                     TestLog.Compare(DataReader.LookupNamespace("b"), strB, "Compare LookupNamespace-b");
336                     TestLog.Compare(DataReader.LookupNamespace("c"), strC, "Compare LookupNamespace-c");
337                     TestLog.Compare(DataReader.LookupNamespace("d"), strD, "Compare LookupNamespace-d");
338                     TestLog.Compare(DataReader.LookupNamespace("e"), strE, "Compare LookupNamespace-e");
339                     TestLog.Compare(DataReader.LookupNamespace("f"), strF, "Compare LookupNamespace-f");
340                     TestLog.Compare(DataReader.LookupNamespace("g"), strG, "Compare LookupNamespace-g");
341                     TestLog.Compare(DataReader.LookupNamespace("h"), strH, "Compare LookupNamespace-h");
342                 }
343 
344                 //[Variation("Namespace test with multiple Namespace declaration, including default namespace")]
LookupNamespace7()345                 public void LookupNamespace7()
346                 {
347                     XmlReader DataReader = GetReader();
348                     PositionOnElement(DataReader, "NAMESPACE3");
349 
350                     string strDef = "1";
351                     string strA = null;
352                     string strB = null;
353                     string strC = null;
354                     string strD = null;
355                     string strE = null;
356                     string strF = null;
357                     string strG = null;
358                     string strH = null;
359                     while (true == DataReader.Read())
360                     {
361                         if (DataReader.Name == "a")
362                         {
363                             strA = "2";
364                             strB = "3";
365                             strC = "4";
366                             CompareAllNS(DataReader, strDef, strA, strB, strC, strD, strE, strF, strG, strH);
367                             if (DataReader.NodeType == XmlNodeType.EndElement)
368                             {
369                                 strA = null;
370                                 strB = null;
371                                 strC = null;
372                             }
373                         }
374                         else if (DataReader.Name == "b")
375                         {
376                             strD = "5";
377                             strE = "6";
378                             strF = "7";
379                             CompareAllNS(DataReader, strDef, strA, strB, strC, strD, strE, strF, strG, strH);
380                             if (DataReader.NodeType == XmlNodeType.EndElement)
381                             {
382                                 strD = null;
383                                 strE = null;
384                                 strF = null;
385                             }
386                         }
387                         else if (DataReader.Name == "c")
388                         {
389                             strD = "8";
390                             strE = "9";
391                             strF = "10";
392                             CompareAllNS(DataReader, strDef, strA, strB, strC, strD, strE, strF, strG, strH);
393                             if (DataReader.NodeType == XmlNodeType.EndElement)
394                             {
395                                 strD = "5";
396                                 strE = "6";
397                                 strF = "7";
398                             }
399                         }
400                         else if (DataReader.Name == "d")
401                         {
402                             strG = "11";
403                             strH = "12";
404                             CompareAllNS(DataReader, strDef, strA, strB, strC, strD, strE, strF, strG, strH);
405                             if (DataReader.NodeType == XmlNodeType.EndElement)
406                             {
407                                 strG = null;
408                                 strH = null;
409                             }
410                         }
411                         else if (DataReader.Name == "testns")
412                         {
413                             strDef = "100";
414                             CompareAllNS(DataReader, strDef, strA, strB, strC, strD, strE, strF, strG, strH);
415                             if (DataReader.NodeType == XmlNodeType.EndElement)
416                             {
417                                 strDef = "1";
418                             }
419                         }
420                         else if (DataReader.Name == "a13")
421                         {
422                             strA = "13";
423                             CompareAllNS(DataReader, strDef, strA, strB, strC, strD, strE, strF, strG, strH);
424                             do
425                             {
426                                 CompareAllNS(DataReader, strDef, strA, strB, strC, strD, strE, strF, strG, strH);
427                             } while (DataReader.MoveToNextAttribute() == true);
428                             strA = null;
429                         }
430                         else if (DataReader.Name == "check14")
431                         {
432                             strDef = "14";
433                             CompareAllNS(DataReader, strDef, strA, strB, strC, strD, strE, strF, strG, strH);
434                             if (DataReader.NodeType == XmlNodeType.EndElement)
435                             {
436                                 strDef = "1";
437                             }
438                         }
439                         else
440                             CompareAllNS(DataReader, strDef, strA, strB, strC, strD, strE, strF, strG, strH);
441 
442                         if (DataReader.Name == "NAMESPACE3" && DataReader.NodeType == XmlNodeType.EndElement)
443                         {
444                             CompareAllNS(DataReader, strDef, strA, strB, strC, strD, strE, strF, strG, strH);
445                             DataReader.Read();
446                             break;
447                         }
448                     }
449                 }
450 
451                 //[Variation("LookupNamespace on whitespace node PreserveWhitespaces = true", Priority = 0)]
LookupNamespace8()452                 public void LookupNamespace8()
453                 {
454                     string strxml = "<ROOT xmlns:p='1'>\n<E1/></ROOT>";
455                     XmlReader DataReader = GetReaderStr(strxml);
456                     PositionOnNodeType(DataReader, XmlNodeType.Text);
457                     string ns = DataReader.LookupNamespace("p");
458                     TestLog.Compare(ns, "1", "ln");
459                 }
460 
461                 //[Variation("Different prefix on inner element for the same namespace", Priority = 0)]
LookupNamespace9()462                 public void LookupNamespace9()
463                 {
464                     string ns = "http://www.w3.org/1999/XMLSchema";
465                     string filename = Path.Combine("TestData", "XmlReader", "Common", "bug_57723.xml");
466 
467                     XmlReader DataReader = GetReader(filename);
468 
469                     PositionOnElement(DataReader, "element");
470                     TestLog.Compare(DataReader.LookupNamespace("q1"), ns, "q11");
471                     TestLog.Compare(DataReader.LookupNamespace("q2"), null, "q21");
472 
473                     DataReader.Read();
474                     PositionOnElement(DataReader, "element");
475                     TestLog.Compare(DataReader.LookupNamespace("q1"), ns, "q12");
476                     TestLog.Compare(DataReader.LookupNamespace("q2"), ns, "q22");
477                 }
478 
479                 //[Variation("LookupNamespace when Namespaces = false", Priority = 0)]
LookupNamespace10()480                 public void LookupNamespace10()
481                 {
482                     string strxml = "<ROOT xmlns:p='1'>\n<E1/></ROOT>";
483                     XmlReader DataReader = GetReaderStr(strxml);
484                     PositionOnElement(DataReader, "ROOT");
485                     TestLog.Compare(DataReader.LookupNamespace("p"), "1", "ln ROOT");
486                     PositionOnElement(DataReader, "E1");
487                     TestLog.Compare(DataReader.LookupNamespace("p"), "1", "ln E1");
488                     DataReader.Read();
489                     TestLog.Compare(DataReader.LookupNamespace("p"), "1", "ln /ROOT");
490                 }
491             }
492 
493             public partial class TCHasValue : BridgeHelpers
494             {
495                 //[Variation("HasValue On None")]
TestHasValueNodeType_None()496                 public void TestHasValueNodeType_None()
497                 {
498                     XmlReader DataReader = GetReader();
499                     bool b = DataReader.HasValue;
500                     if (b)
501                         throw new TestException(TestResult.Failed, "");
502                 }
503 
504                 //[Variation("HasValue On Element", Priority = 0)]
TestHasValueNodeType_Element()505                 public void TestHasValueNodeType_Element()
506                 {
507                     XmlReader DataReader = GetReader();
508                     while (FindNodeType(DataReader, XmlNodeType.Element))
509                     {
510                         bool b = DataReader.HasValue;
511                         if (b)
512                             throw new TestFailedException("HasValue returns True");
513                         else
514                             return;
515                     }
516                 }
517 
518                 //[Variation("Get node with a scalar value, verify the value with valid ReadString")]
TestHasValue1()519                 public void TestHasValue1()
520                 {
521                     XmlReader DataReader = GetReader();
522                     PositionOnElement(DataReader, "NONEMPTY1");
523                     DataReader.Read();
524                     TestLog.Compare(DataReader.HasValue, true, "HasValue test");
525                 }
526 
527                 //[Variation("HasValue On Attribute", Priority = 0)]
TestHasValueNodeType_Attribute()528                 public void TestHasValueNodeType_Attribute()
529                 {
530                     XmlReader DataReader = GetReader();
531                     while (FindNodeType(DataReader, XmlNodeType.Attribute))
532                     {
533                         bool b = DataReader.HasValue;
534                         if (!b)
535                             throw new TestFailedException("HasValue for Attribute returns false");
536                         else
537                             return;
538                     }
539                 }
540 
541                 //[Variation("HasValue On Text", Priority = 0)]
TestHasValueNodeType_Text()542                 public void TestHasValueNodeType_Text()
543                 {
544                     XmlReader DataReader = GetReader();
545                     while (FindNodeType(DataReader, XmlNodeType.Text))
546                     {
547                         bool b = DataReader.HasValue;
548                         if (!b)
549                             throw new TestFailedException("HasValue for Text returns false");
550                         else
551                             return;
552                     }
553                 }
554 
555                 //[Variation("HasValue On CDATA", Priority = 0)]
TestHasValueNodeType_CDATA()556                 public void TestHasValueNodeType_CDATA()
557                 {
558                     XmlReader DataReader = GetReader();
559 
560                     while (FindNodeType(DataReader, XmlNodeType.CDATA))
561                     {
562                         bool b = DataReader.HasValue;
563                         if (!b)
564                             throw new TestFailedException("HasValue for CDATA returns false");
565                         else
566                             return;
567                     }
568                 }
569 
570                 //[Variation("HasValue On ProcessingInstruction", Priority = 0)]
TestHasValueNodeType_ProcessingInstruction()571                 public void TestHasValueNodeType_ProcessingInstruction()
572                 {
573                     XmlReader DataReader = GetReader();
574                     while (FindNodeType(DataReader, XmlNodeType.ProcessingInstruction))
575                     {
576                         bool b = DataReader.HasValue;
577                         if (!b)
578                             throw new TestException(TestResult.Failed, "HasValue for PI returns false");
579                         else
580                             return;
581                     }
582                 }
583 
584                 //[Variation("HasValue On Comment", Priority = 0)]
TestHasValueNodeType_Comment()585                 public void TestHasValueNodeType_Comment()
586                 {
587                     XmlReader DataReader = GetReader();
588                     while (FindNodeType(DataReader, XmlNodeType.Comment))
589                     {
590                         bool b = DataReader.HasValue;
591                         if (!b)
592                             throw new TestException(TestResult.Failed, "HasValue for Comment returns false");
593                         else
594                             return;
595                     }
596                 }
597 
598                 //[Variation("HasValue On DocumentType", Priority = 0)]
TestHasValueNodeType_DocumentType()599                 public void TestHasValueNodeType_DocumentType()
600                 {
601                     XmlReader DataReader = GetReader();
602                     if (FindNodeType(DataReader, XmlNodeType.DocumentType))
603                     {
604                         bool b = DataReader.HasValue;
605                         if (!b)
606                             throw new TestException(TestResult.Failed, "HasValue returns True");
607                         else
608                             return;
609                     }
610                 }
611 
612                 //[Variation("HasValue On Whitespace PreserveWhitespaces = true", Priority = 0)]
TestHasValueNodeType_Whitespace()613                 public void TestHasValueNodeType_Whitespace()
614                 {
615                     XmlReader DataReader = GetReader();
616                     while (FindNodeType(DataReader, XmlNodeType.Whitespace))
617                     {
618                         bool b = DataReader.HasValue;
619                         if (!b)
620                             throw new TestException(TestResult.Failed, "HasValue returns False");
621                         else
622                             return;
623                     }
624                 }
625 
626                 //[Variation("HasValue On EndElement")]
TestHasValueNodeType_EndElement()627                 public void TestHasValueNodeType_EndElement()
628                 {
629                     XmlReader DataReader = GetReader();
630                     while (FindNodeType(DataReader, XmlNodeType.EndElement))
631                     {
632                         bool b = DataReader.HasValue;
633                         if (b)
634                             throw new TestException(TestResult.Failed, "HasValue returns True");
635                         else
636                             return;
637                     }
638                 }
639 
640                 //[Variation("HasValue On XmlDeclaration", Priority = 0)]
TestHasValueNodeType_XmlDeclaration()641                 public void TestHasValueNodeType_XmlDeclaration()
642                 {
643                     XmlReader DataReader = GetReader();
644                     if (FindNodeType(DataReader, XmlNodeType.XmlDeclaration))
645                     {
646                         bool b = DataReader.HasValue;
647                         if (!b)
648                             throw new TestException(TestResult.Failed, "HasValue returns False");
649                         else
650                             return;
651                     }
652                 }
653 
654                 //[Variation("HasValue On EntityReference")]
TestHasValueNodeType_EntityReference()655                 public void TestHasValueNodeType_EntityReference()
656                 {
657                     XmlReader DataReader = GetReader();
658                     if (FindNodeType(DataReader, XmlNodeType.EntityReference))
659                     {
660                         bool b = DataReader.HasValue;
661                         if (b)
662                             throw new TestException(TestResult.Failed, "HasValue returns True");
663                         else
664                             return;
665                     }
666                 }
667 
668                 //[Variation("HasValue On EndEntity")]
TestHasValueNodeType_EndEntity()669                 public void TestHasValueNodeType_EndEntity()
670                 {
671                     XmlReader DataReader = GetReader();
672                     while (FindNodeType(DataReader, XmlNodeType.EndEntity))
673                     {
674                         bool b = DataReader.HasValue;
675                         if (b)
676                             throw new TestException(TestResult.Failed, "HasValue returns True");
677                         else
678                             return;
679                     }
680                 }
681 
682                 //[Variation("PI Value containing surrogates", Priority = 0)]
v13()683                 public void v13()
684                 {
685                     string strxml = "<root><?target \uD800\uDC00\uDBFF\uDFFF?></root>";
686                     XmlReader DataReader = GetReaderStr(strxml);
687                     DataReader.Read();
688                     DataReader.Read();
689                     TestLog.Compare(DataReader.NodeType, XmlNodeType.ProcessingInstruction, "nt");
690                     TestLog.Compare(DataReader.Value, "\uD800\uDC00\uDBFF\uDFFF", "piv");
691                 }
692             }
693 
694             public partial class TCIsEmptyElement2 : BridgeHelpers
695             {
696                 //[Variation("Set and Get an element that ends with />", Priority = 0)]
TestEmpty1()697                 public void TestEmpty1()
698                 {
699                     XmlReader DataReader = GetReader();
700                     PositionOnElement(DataReader, "EMPTY1");
701                     bool b = DataReader.IsEmptyElement;
702                     if (!b)
703                         throw new TestException(TestResult.Failed, "DataReader is NOT_EMPTY, supposed to be EMPTY");
704                 }
705 
706                 //[Variation("Set and Get an element with an attribute that ends with />", Priority = 0)]
TestEmpty2()707                 public void TestEmpty2()
708                 {
709                     XmlReader DataReader = GetReader();
710                     PositionOnElement(DataReader, "EMPTY2");
711                     bool b = DataReader.IsEmptyElement;
712                     if (!b)
713                         throw new TestException(TestResult.Failed, "DataReader is NOT_EMPTY, supposed to be EMPTY");
714                 }
715 
716                 //[Variation("Set and Get an element that ends without />", Priority = 0)]
TestEmpty3()717                 public void TestEmpty3()
718                 {
719                     XmlReader DataReader = GetReader();
720                     PositionOnElement(DataReader, "NONEMPTY1");
721                     bool b = DataReader.IsEmptyElement;
722                     if (b)
723                         throw new TestException(TestResult.Failed, "DataReader is EMPTY, supposed to be NOT_EMPTY");
724                 }
725 
726                 //[Variation("Set and Get an element with an attribute that ends with />", Priority = 0)]
TestEmpty4()727                 public void TestEmpty4()
728                 {
729                     XmlReader DataReader = GetReader();
730                     PositionOnElement(DataReader, "NONEMPTY2");
731                     bool b = DataReader.IsEmptyElement;
732                     if (b)
733                         throw new TestException(TestResult.Failed, "DataReader is EMPTY, supposed to be NOT_EMPTY");
734                 }
735 
736                 //[Variation("IsEmptyElement On Element", Priority = 0)]
TestEmptyNodeType_Element()737                 public void TestEmptyNodeType_Element()
738                 {
739                     XmlReader DataReader = GetReader();
740                     while (FindNodeType(DataReader, XmlNodeType.Element))
741                     {
742                         bool b = DataReader.IsEmptyElement;
743                         if (b)
744                             throw new TestException(TestResult.Failed, "IsEmptyElement returns True");
745                         else
746                             return;
747                     }
748                 }
749 
750                 //[Variation("IsEmptyElement On None")]
TestEmptyNodeType_None()751                 public void TestEmptyNodeType_None()
752                 {
753                     XmlReader DataReader = GetReader();
754                     bool b = DataReader.IsEmptyElement;
755                     if (b)
756                         throw new TestException(TestResult.Failed, "");
757                 }
758 
759                 //[Variation("IsEmptyElement On Text")]
TestEmptyNodeType_Text()760                 public void TestEmptyNodeType_Text()
761                 {
762                     XmlReader DataReader = GetReader();
763                     while (FindNodeType(DataReader, XmlNodeType.Text))
764                     {
765                         bool b = DataReader.IsEmptyElement;
766                         if (b)
767                             throw new TestException(TestResult.Failed, "IsEmptyElement returns True");
768                         else
769                             return;
770                     }
771                 }
772 
773                 //[Variation("IsEmptyElement On CDATA")]
TestEmptyNodeType_CDATA()774                 public void TestEmptyNodeType_CDATA()
775                 {
776                     XmlReader DataReader = GetReader();
777                     while (FindNodeType(DataReader, XmlNodeType.CDATA))
778                     {
779                         bool b = DataReader.IsEmptyElement;
780                         if (b)
781                             throw new TestException(TestResult.Failed, "IsEmptyElement returns True");
782                         else
783                             return;
784                     }
785                 }
786 
787                 //[Variation("IsEmptyElement On ProcessingInstruction")]
TestEmptyNodeType_ProcessingInstruction()788                 public void TestEmptyNodeType_ProcessingInstruction()
789                 {
790                     XmlReader DataReader = GetReader();
791                     while (FindNodeType(DataReader, XmlNodeType.ProcessingInstruction))
792                     {
793                         bool b = DataReader.IsEmptyElement;
794                         if (b)
795                             throw new TestException(TestResult.Failed, "IsEmptyElement returns True");
796                         else
797                             return;
798                     }
799                 }
800 
801                 //[Variation("IsEmptyElement On Comment")]
TestEmptyNodeType_Comment()802                 public void TestEmptyNodeType_Comment()
803                 {
804                     XmlReader DataReader = GetReader();
805                     while (FindNodeType(DataReader, XmlNodeType.Comment))
806                     {
807                         bool b = DataReader.IsEmptyElement;
808                         if (!b)
809                             return;
810                         else
811                             throw new TestException(TestResult.Failed, "IsEmptyElement returns True");
812                     }
813                 }
814 
815                 //[Variation("IsEmptyElement On DocumentType")]
TestEmptyNodeType_DocumentType()816                 public void TestEmptyNodeType_DocumentType()
817                 {
818                     XmlReader DataReader = GetReader();
819                     if (FindNodeType(DataReader, XmlNodeType.DocumentType))
820                     {
821                         bool b = DataReader.IsEmptyElement;
822                         if (!b)
823                             return;
824                         else
825                             throw new TestException(TestResult.Failed, "IsEmptyElement returns True");
826                     }
827                 }
828 
829                 //[Variation("IsEmptyElement On Whitespace PreserveWhitespaces = true")]
TestEmptyNodeType_Whitespace()830                 public void TestEmptyNodeType_Whitespace()
831                 {
832                     XmlReader DataReader = GetReader();
833                     while (FindNodeType(DataReader, XmlNodeType.Whitespace))
834                     {
835                         bool b = DataReader.IsEmptyElement;
836                         if (!b)
837                             return;
838                         else
839                             throw new TestException(TestResult.Failed, "IsEmptyElement returns True");
840                     }
841                 }
842 
843                 //[Variation("IsEmptyElement On EndElement")]
TestEmptyNodeType_EndElement()844                 public void TestEmptyNodeType_EndElement()
845                 {
846                     XmlReader DataReader = GetReader();
847                     while (FindNodeType(DataReader, XmlNodeType.EndElement))
848                     {
849                         bool b = DataReader.IsEmptyElement;
850                         if (!b)
851                             return;
852                         else
853                             throw new TestException(TestResult.Failed, "IsEmptyElement returns True");
854                     }
855                 }
856 
857                 //[Variation("IsEmptyElement On EntityReference")]
TestEmptyNodeType_EntityReference()858                 public void TestEmptyNodeType_EntityReference()
859                 {
860                     XmlReader DataReader = GetReader();
861                     while (FindNodeType(DataReader, XmlNodeType.EntityReference))
862                     {
863                         bool b = DataReader.IsEmptyElement;
864                         if (!b)
865                             return;
866                         else
867                             throw new TestException(TestResult.Failed, "IsEmptyElement returns True");
868                     }
869                 }
870 
871                 //[Variation("IsEmptyElement On EndEntity")]
TestEmptyNodeType_EndEntity()872                 public void TestEmptyNodeType_EndEntity()
873                 {
874                     XmlReader DataReader = GetReader();
875                     while (FindNodeType(DataReader, XmlNodeType.EndEntity))
876                     {
877                         bool b = DataReader.IsEmptyElement;
878                         if (!b)
879                             return;
880                         else
881                             throw new TestException(TestResult.Failed, "IsEmptyElement returns True");
882                     }
883                 }
884             }
885 
886             public partial class TCXmlSpace : BridgeHelpers
887             {
888                 //[Variation("XmlSpace test within EmptyTag")]
TestXmlSpace1()889                 public void TestXmlSpace1()
890                 {
891                     XmlReader DataReader = GetReader();
892                     PositionOnElement(DataReader, "EMPTY_XMLSPACE");
893 
894                     do
895                     {
896                         TestLog.Compare(DataReader.XmlSpace, XmlSpace.Default, "Compare XmlSpace with Default");
897                     } while (DataReader.MoveToNextAttribute() == true);
898                 }
899 
900                 //[Variation("Xmlspace test within a scope (no nested element)", Priority = 0)]
TestXmlSpace2()901                 public void TestXmlSpace2()
902                 {
903                     XmlReader DataReader = GetReader();
904                     while (true == DataReader.Read())
905                     {
906                         if (DataReader.Name == "XMLSPACE1") break;
907                         TestLog.Compare(DataReader.XmlSpace, XmlSpace.None, "Compare XmlSpace with None");
908                     }
909 
910                     while (true == DataReader.Read())
911                     {
912                         if (DataReader.Name == "XMLSPACE1" && (DataReader.NodeType == XmlNodeType.EndElement)) break;
913                         TestLog.Compare(DataReader.XmlSpace, XmlSpace.Default, "Compare XmlSpace with Default");
914                     }
915                 }
916 
917                 //[Variation("Xmlspace test within a scope (with nested element)", Priority = 0)]
TestXmlSpace3()918                 public void TestXmlSpace3()
919                 {
920                     XmlReader DataReader = GetReader();
921                     PositionOnElement(DataReader, "XMLSPACE2");
922                     while (true == DataReader.Read())
923                     {
924                         if (DataReader.Name == "NOSPACE") break;
925                         TestLog.Compare(DataReader.XmlSpace, XmlSpace.Preserve, "Compare XmlSpace with Preserve");
926                     }
927                     TestLog.Compare(DataReader.XmlSpace, XmlSpace.None, "Compare XmlSpace outside scope");
928                 }
929 
930                 //[Variation("Xmlspace test immediately outside the XmlSpace scope")]
TestXmlSpace4()931                 public void TestXmlSpace4()
932                 {
933                     XmlReader DataReader = GetReader();
934                     PositionOnElement(DataReader, "NOSPACE");
935                     TestLog.Compare(DataReader.XmlSpace, XmlSpace.None, "Compare XmlSpace with None");
936                 }
937 
938                 //[Variation("XmlSpace test with multiple XmlSpace declaration")]
TestXmlSpace5()939                 public void TestXmlSpace5()
940                 {
941                     XmlReader DataReader = GetReader();
942                     PositionOnElement(DataReader, "XMLSPACE2A");
943 
944                     while (true == DataReader.Read())
945                     {
946                         if (DataReader.Name == "XMLSPACE3") break;
947                         TestLog.Compare(DataReader.XmlSpace, XmlSpace.Default, "Compare XmlSpace with Default");
948                     }
949 
950                     while (true == DataReader.Read())
951                     {
952                         if (DataReader.Name == "XMLSPACE4")
953                         {
954                             while (true == DataReader.Read())
955                             {
956                                 TestLog.Compare(DataReader.XmlSpace, XmlSpace.Default, "Compare XmlSpace with Default");
957                                 if (DataReader.Name == "XMLSPACE4" && DataReader.NodeType == XmlNodeType.EndElement)
958                                 {
959                                     DataReader.Read();
960                                     break;
961                                 }
962                             }
963                         }
964 
965                         TestLog.Compare(DataReader.XmlSpace, XmlSpace.Preserve, "Compare XmlSpace with Preserve");
966 
967                         if (DataReader.Name == "XMLSPACE3" && DataReader.NodeType == XmlNodeType.EndElement)
968                         {
969                             DataReader.Read();
970                             break;
971                         }
972                     }
973 
974                     do
975                     {
976                         TestLog.Compare(DataReader.XmlSpace, XmlSpace.Default, "Compare XmlSpace with Default");
977                         if (DataReader.Name == "XMLSPACE2A" && DataReader.NodeType == XmlNodeType.EndElement)
978                         {
979                             DataReader.Read();
980                             break;
981                         }
982                     } while (true == DataReader.Read());
983 
984                     TestLog.Compare(DataReader.XmlSpace, XmlSpace.None, "Compare XmlSpace outside scope");
985                 }
986             }
987 
988             public partial class TCXmlLang : BridgeHelpers
989             {
990                 //[Variation("XmlLang test within EmptyTag")]
TestXmlLang1()991                 public void TestXmlLang1()
992                 {
993                     XmlReader DataReader = GetReader();
994                     PositionOnElement(DataReader, "EMPTY_XMLLANG");
995                     do
996                     {
997                         TestLog.Compare(DataReader.XmlLang, "en-US", "Compare XmlLang with en-US");
998                     } while (DataReader.MoveToNextAttribute() == true);
999                 }
1000 
1001                 //[Variation("XmlLang test within a scope (no nested element)", Priority = 0)]
TestXmlLang2()1002                 public void TestXmlLang2()
1003                 {
1004                     XmlReader DataReader = GetReader();
1005                     while (true == DataReader.Read())
1006                     {
1007                         if (DataReader.Name == "XMLLANG0") break;
1008                         TestLog.Compare(DataReader.XmlLang, String.Empty, "Compare XmlLang with String.Empty");
1009                     }
1010 
1011                     while (true == DataReader.Read())
1012                     {
1013                         if (DataReader.Name == "XMLLANG0" && (DataReader.NodeType == XmlNodeType.EndElement)) break;
1014 
1015                         if (DataReader.NodeType == XmlNodeType.EntityReference)
1016                         {
1017                             TestLog.Compare(DataReader.XmlLang, "en-US", "Compare XmlLang with EntityRef");
1018 
1019                             if (DataReader.CanResolveEntity)
1020                             {
1021                                 DataReader.ResolveEntity();
1022                                 TestLog.Compare(DataReader.XmlLang, "en-US", "Compare XmlLang after ResolveEntity");
1023                                 while (DataReader.Read() && DataReader.NodeType != XmlNodeType.EndEntity)
1024                                 {
1025                                     TestLog.Compare(DataReader.XmlLang, "en-US", "Compare XmlLang While Read ");
1026                                 }
1027                                 if (DataReader.NodeType == XmlNodeType.EndEntity)
1028                                 {
1029                                     TestLog.Compare(DataReader.XmlLang, "en-US", "Compare XmlLang at EndEntity ");
1030                                 }
1031                             }
1032                         }
1033                         else
1034                             TestLog.Compare(DataReader.XmlLang, "en-US", "Compare XmlLang with Preserve");
1035                     }
1036                 }
1037 
1038                 //[Variation("XmlLang test within a scope (with nested element)", Priority = 0)]
TestXmlLang3()1039                 public void TestXmlLang3()
1040                 {
1041                     XmlReader DataReader = GetReader();
1042                     PositionOnElement(DataReader, "XMLLANG1");
1043 
1044                     while (true == DataReader.Read())
1045                     {
1046                         if (DataReader.Name == "NOXMLLANG") break;
1047                         TestLog.Compare(DataReader.XmlLang, "en-GB", "Compare XmlLang with en-GB");
1048                     }
1049                 }
1050 
1051                 //[Variation("XmlLang test immediately outside the XmlLang scope")]
TestXmlLang4()1052                 public void TestXmlLang4()
1053                 {
1054                     XmlReader DataReader = GetReader();
1055                     PositionOnElement(DataReader, "NOXMLLANG");
1056                     TestLog.Compare(DataReader.XmlLang, String.Empty, "Compare XmlLang with EmptyString");
1057                 }
1058 
1059                 //[Variation("XmlLang test with multiple XmlLang declaration")]
TestXmlLang5()1060                 public void TestXmlLang5()
1061                 {
1062                     XmlReader DataReader = GetReader();
1063                     PositionOnElement(DataReader, "XMLLANG2");
1064                     while (true == DataReader.Read())
1065                     {
1066                         if (DataReader.Name == "XMLLANG1") break;
1067                         TestLog.Compare(DataReader.XmlLang, "en-US", "Compare XmlLang with Preserve");
1068                     }
1069 
1070                     while (true == DataReader.Read())
1071                     {
1072                         if (DataReader.Name == "XMLLANG0")
1073                         {
1074                             while (true == DataReader.Read())
1075                             {
1076                                 TestLog.Compare(DataReader.XmlLang, "en-US", "Compare XmlLang with en-US");
1077                                 if (DataReader.Name == "XMLLANG0" && DataReader.NodeType == XmlNodeType.EndElement)
1078                                 {
1079                                     DataReader.Read();
1080                                     break;
1081                                 }
1082                             }
1083                         }
1084 
1085                         TestLog.Compare(DataReader.XmlLang, "en-GB", "Compare XmlLang with en_GB");
1086 
1087                         if (DataReader.Name == "XMLLANG1" && DataReader.NodeType == XmlNodeType.EndElement)
1088                         {
1089                             DataReader.Read();
1090                             break;
1091                         }
1092                     }
1093 
1094                     do
1095                     {
1096                         TestLog.Compare(DataReader.XmlLang, "en-US", "Compare XmlLang with en-US");
1097                         if (DataReader.Name == "XMLLANG2" && DataReader.NodeType == XmlNodeType.EndElement)
1098                         {
1099                             DataReader.Read();
1100                             break;
1101                         }
1102                     } while (true == DataReader.Read());
1103                 }
1104 
1105                 // XML 1.0 SE
1106                 //[Variation("XmlLang valid values", Priority = 0)]
TestXmlLang6()1107                 public void TestXmlLang6()
1108                 {
1109                     const string ST_VALIDXMLLANG = "VALIDXMLLANG";
1110                     string[] aValidLang = { "a", "", "ab-cd-", "a b-cd" };
1111 
1112                     XmlReader DataReader = GetReader();
1113 
1114                     for (int i = 0; i < aValidLang.Length; i++)
1115                     {
1116                         string strelem = ST_VALIDXMLLANG + i;
1117                         PositionOnElement(DataReader, strelem);
1118                         //DataReader.Read();
1119                         TestLog.Compare(DataReader.XmlLang, aValidLang[i], "XmlLang");
1120                     }
1121                 }
1122 
1123                 // XML 1.0 SE
1124                 //[Variation("More XmlLang valid values")]
TestXmlTextReaderLang1()1125                 public void TestXmlTextReaderLang1()
1126                 {
1127                     string[] aValidLang = { "", "ab-cd-", "abcdefghi", "ab-cdefghijk", "a b-cd", "ab-c d" };
1128 
1129                     for (int i = 0; i < aValidLang.Length; i++)
1130                     {
1131                         string strxml = String.Format("<ROOT xml:lang='{0}'/>", aValidLang[i]);
1132 
1133                         XmlReader DataReader = GetReaderStr(strxml);
1134 
1135                         while (DataReader.Read()) ;
1136                     }
1137                 }
1138             }
1139 
1140             public partial class TCSkip : BridgeHelpers
1141             {
VerifySkipOnNodeType(XmlNodeType testNodeType)1142                 public bool VerifySkipOnNodeType(XmlNodeType testNodeType)
1143                 {
1144                     bool bPassed = false;
1145                     XmlNodeType actNodeType;
1146                     String strActName;
1147                     String strActValue;
1148 
1149                     XmlReader DataReader = GetReader();
1150                     PositionOnNodeType(DataReader, testNodeType);
1151                     DataReader.Read();
1152                     actNodeType = DataReader.NodeType;
1153                     strActName = DataReader.Name;
1154                     strActValue = DataReader.Value;
1155 
1156                     DataReader = GetReader();
1157                     PositionOnNodeType(DataReader, testNodeType);
1158                     DataReader.Skip();
1159                     bPassed = VerifyNode(DataReader, actNodeType, strActName, strActValue);
1160 
1161                     return bPassed;
1162                 }
1163 
1164                 //[Variation("Call Skip on empty element", Priority = 0)]
TestSkip1()1165                 public void TestSkip1()
1166                 {
1167                     bool bPassed = false;
1168 
1169                     XmlReader DataReader = GetReader();
1170                     PositionOnElement(DataReader, "SKIP1");
1171 
1172                     DataReader.Skip();
1173 
1174                     bPassed = VerifyNode(DataReader, XmlNodeType.Element, "AFTERSKIP1", String.Empty);
1175 
1176                     BoolToLTMResult(bPassed);
1177                 }
1178 
1179                 //[Variation("Call Skip on element", Priority = 0)]
TestSkip2()1180                 public void TestSkip2()
1181                 {
1182                     bool bPassed = false;
1183 
1184                     XmlReader DataReader = GetReader();
1185                     PositionOnElement(DataReader, "SKIP2");
1186 
1187                     DataReader.Skip();
1188 
1189                     bPassed = VerifyNode(DataReader, XmlNodeType.Element, "AFTERSKIP2", String.Empty);
1190 
1191                     BoolToLTMResult(bPassed);
1192                 }
1193 
1194                 //[Variation("Call Skip on element with content", Priority = 0)]
TestSkip3()1195                 public void TestSkip3()
1196                 {
1197                     bool bPassed = false;
1198 
1199                     XmlReader DataReader = GetReader();
1200                     PositionOnElement(DataReader, "SKIP3");
1201 
1202                     DataReader.Skip();
1203 
1204                     bPassed = VerifyNode(DataReader, XmlNodeType.Element, "AFTERSKIP3", String.Empty);
1205 
1206                     BoolToLTMResult(bPassed);
1207                 }
1208 
1209                 //[Variation("Call Skip on text node (leave node)", Priority = 0)]
TestSkip4()1210                 public void TestSkip4()
1211                 {
1212                     bool bPassed = false;
1213 
1214                     XmlReader DataReader = GetReader();
1215                     PositionOnElement(DataReader, "SKIP3");
1216                     PositionOnElement(DataReader, "ELEM2");
1217                     DataReader.Read();
1218                     bPassed = (DataReader.NodeType == XmlNodeType.Text);
1219 
1220                     DataReader.Skip();
1221 
1222                     bPassed = VerifyNode(DataReader, XmlNodeType.EndElement, "ELEM2", String.Empty) && bPassed;
1223 
1224                     BoolToLTMResult(bPassed);
1225                 }
1226 
1227                 //[Variation("Call Skip in while read loop", Priority = 0)]
skip307543()1228                 public void skip307543()
1229                 {
1230                     XmlReader DataReader = GetReader(Path.Combine("TestData", "XmlReader", "Common", "skip307543.xml"));
1231                     while (DataReader.Read())
1232                         DataReader.Skip();
1233                 }
1234 
1235                 //[Variation("Call Skip on text node with another element: <elem2>text<elem3></elem3></elem2>")]
TestSkip5()1236                 public void TestSkip5()
1237                 {
1238                     bool bPassed = false;
1239 
1240                     XmlReader DataReader = GetReader();
1241                     PositionOnElement(DataReader, "SKIP4");
1242                     PositionOnElement(DataReader, "ELEM2");
1243                     DataReader.Read();
1244                     bPassed = (DataReader.NodeType == XmlNodeType.Text);
1245 
1246                     DataReader.Skip();
1247 
1248                     bPassed = VerifyNode(DataReader, XmlNodeType.Element, "ELEM3", String.Empty) && bPassed;
1249 
1250                     BoolToLTMResult(bPassed);
1251                 }
1252 
1253                 //[Variation("Call Skip on attribute", Priority = 0)]
TestSkip6()1254                 public void TestSkip6()
1255                 {
1256                     bool bPassed = false;
1257 
1258                     XmlReader DataReader = GetReader();
1259                     PositionOnElement(DataReader, ST_ENTTEST_NAME);
1260                     bPassed = DataReader.MoveToFirstAttribute();
1261 
1262                     DataReader.Skip();
1263 
1264                     bPassed = VerifyNode(DataReader, XmlNodeType.Element, "ENTITY2", String.Empty) && bPassed;
1265 
1266                     BoolToLTMResult(bPassed);
1267                 }
1268 
1269                 //[Variation("Call Skip on text node of attribute")]
TestSkip7()1270                 public void TestSkip7()
1271                 {
1272                     bool bPassed = false;
1273 
1274                     XmlReader DataReader = GetReader();
1275 
1276                     PositionOnElement(DataReader, ST_ENTTEST_NAME);
1277                     bPassed = DataReader.MoveToFirstAttribute();
1278                     bPassed = DataReader.ReadAttributeValue() && bPassed;
1279                     bPassed = (DataReader.NodeType == XmlNodeType.Text) && bPassed;
1280 
1281                     DataReader.Skip();
1282 
1283                     bPassed = VerifyNode(DataReader, XmlNodeType.Element, "ENTITY2", String.Empty) && bPassed;
1284 
1285                     BoolToLTMResult(bPassed);
1286                 }
1287 
1288                 //[Variation("Call Skip on CDATA", Priority = 0)]
TestSkip8()1289                 public void TestSkip8()
1290                 {
1291                     XmlReader DataReader = GetReader();
1292                     BoolToLTMResult(VerifySkipOnNodeType(XmlNodeType.CDATA));
1293                 }
1294 
1295                 //[Variation("Call Skip on Processing Instruction", Priority = 0)]
TestSkip9()1296                 public void TestSkip9()
1297                 {
1298                     BoolToLTMResult(VerifySkipOnNodeType(XmlNodeType.ProcessingInstruction));
1299                 }
1300 
1301                 //[Variation("Call Skip on Comment", Priority = 0)]
TestSkip10()1302                 public void TestSkip10()
1303                 {
1304                     BoolToLTMResult(VerifySkipOnNodeType(XmlNodeType.Comment));
1305                 }
1306 
1307                 //[Variation("Call Skip on Whitespace", Priority = 0)]
TestSkip12()1308                 public void TestSkip12()
1309                 {
1310                     XmlReader DataReader = GetReader();
1311                     BoolToLTMResult(VerifySkipOnNodeType(XmlNodeType.Whitespace));
1312                 }
1313 
1314                 //[Variation("Call Skip on EndElement", Priority = 0)]
TestSkip13()1315                 public void TestSkip13()
1316                 {
1317                     BoolToLTMResult(VerifySkipOnNodeType(XmlNodeType.EndElement));
1318                 }
1319 
1320                 //[Variation("Call Skip on root Element")]
TestSkip14()1321                 public void TestSkip14()
1322                 {
1323                     bool bPassed;
1324 
1325                     XmlReader DataReader = GetReader();
1326                     PositionOnNodeType(DataReader, XmlNodeType.Element);
1327 
1328                     DataReader.Skip();
1329 
1330                     bPassed = VerifyNode(DataReader, XmlNodeType.None, String.Empty, String.Empty);
1331 
1332                     BoolToLTMResult(bPassed);
1333                 }
1334 
1335                 //[Variation("XmlTextReader ArgumentOutOfRangeException when handling ampersands")]
XmlTextReaderDoesNotThrowWhenHandlingAmpersands()1336                 public void XmlTextReaderDoesNotThrowWhenHandlingAmpersands()
1337                 {
1338                     string xmlStr = @"<a>
1339 	fffffffffffffffffffffffffffffffffffffff
1340 	fffffffffffffffffffffffffffffffffffffff
1341 	fffffffffffffffffffffffffffffffffffffff
1342 	fffffffffffffffffffffffffffffffffffffff
1343 	fffffffffffffffffffffffffffffffffffffff
1344 	fffffffffffffffffffffffffffffffffffffff
1345 	fffffffffffffffffffffffffffffffffffffff
1346 	fffffffffffffffffffffffffffffffffffffff
1347 	fffffffffffffffffffffffffffffffffffffff
1348 	fffffffffffffffffffffffffffffffffffffff
1349 	fffffffffffffffffffffffffffffffffffffff
1350 	fffffffffffffffffffffffffffffffffffffff
1351 	fffffffffffffffffffffffffffffffffffffff
1352 	fffffffffffffffffffffffffffffffffffffff
1353 	fffffffffffffffffffffffffffffffffffffff
1354 	fffffffffffffffffffffffffffffffffffffff
1355 	fffffffffffffffffffffffffffffffffffffff
1356 &gt;
1357 	fffffffffffffffffffffffffffffffffffffff
1358 	fffffffffffffffffffffffffffffffffffffff
1359 	fffffffffffffffffffffffffffffffffffffff
1360 	fffffffffffffffffffffffffffffffffffffff
1361 	fffffffffffffffffffffffffffffffffffffff
1362 	fffffffffffffffffffffffffffffffffffffff
1363 	fffffffffffffffffffffffffffffffffffffff
1364 	fffffffffffffffffffffffffffffffffffffff
1365 &amp;
1366 </a>
1367 ";
1368                     XmlReader DataReader = GetReader(new StringReader(xmlStr));
1369                     PositionOnElement(DataReader, "a");
1370                     DataReader.Skip();
1371                 }
1372             }
1373 
1374             public partial class TCIsDefault : BridgeHelpers
1375             {
1376             }
1377 
1378             public partial class TCBaseURI : BridgeHelpers
1379             {
1380                 //[Variation("BaseURI for element node", Priority = 0)]
TestBaseURI1()1381                 public void TestBaseURI1()
1382                 {
1383                     bool bPassed = false;
1384                     XmlReader DataReader = GetReader();
1385                     PositionOnNodeType(DataReader, XmlNodeType.Element);
1386                     bPassed = TestLog.Equals(DataReader.BaseURI, String.Empty, Variation.Desc);
1387                     BoolToLTMResult(bPassed);
1388                 }
1389 
1390                 //[Variation("BaseURI for attribute node", Priority = 0)]
TestBaseURI2()1391                 public void TestBaseURI2()
1392                 {
1393                     bool bPassed = false;
1394                     XmlReader DataReader = GetReader();
1395                     PositionOnNodeType(DataReader, XmlNodeType.Attribute);
1396                     bPassed = TestLog.Equals(DataReader.BaseURI, String.Empty, Variation.Desc);
1397                     BoolToLTMResult(bPassed);
1398                 }
1399 
1400                 //[Variation("BaseURI for text node", Priority = 0)]
TestBaseURI3()1401                 public void TestBaseURI3()
1402                 {
1403                     bool bPassed = false;
1404                     XmlReader DataReader = GetReader();
1405                     PositionOnNodeType(DataReader, XmlNodeType.Text);
1406                     bPassed = TestLog.Equals(DataReader.BaseURI, String.Empty, Variation.Desc);
1407                     BoolToLTMResult(bPassed);
1408                 }
1409 
1410                 //[Variation("BaseURI for CDATA node")]
TestBaseURI4()1411                 public void TestBaseURI4()
1412                 {
1413                     XmlReader DataReader = GetReader();
1414                     bool bPassed = false;
1415                     PositionOnNodeType(DataReader, XmlNodeType.CDATA);
1416                     bPassed = TestLog.Equals(DataReader.BaseURI, String.Empty, Variation.Desc);
1417                     BoolToLTMResult(bPassed);
1418                 }
1419 
1420                 //[Variation("BaseURI for PI node")]
TestBaseURI6()1421                 public void TestBaseURI6()
1422                 {
1423                     bool bPassed = false;
1424                     XmlReader DataReader = GetReader();
1425                     PositionOnNodeType(DataReader, XmlNodeType.ProcessingInstruction);
1426                     bPassed = TestLog.Equals(DataReader.BaseURI, String.Empty, Variation.Desc);
1427                     BoolToLTMResult(bPassed);
1428                 }
1429 
1430                 //[Variation("BaseURI for Comment node")]
TestBaseURI7()1431                 public void TestBaseURI7()
1432                 {
1433                     bool bPassed = false;
1434                     XmlReader DataReader = GetReader();
1435                     PositionOnNodeType(DataReader, XmlNodeType.Comment);
1436                     bPassed = TestLog.Equals(DataReader.BaseURI, String.Empty, Variation.Desc);
1437                     BoolToLTMResult(bPassed);
1438                 }
1439 
1440                 //[Variation("BaseURI for Whitespace node PreserveWhitespaces = true")]
TestBaseURI9()1441                 public void TestBaseURI9()
1442                 {
1443                     bool bPassed = false;
1444                     XmlReader DataReader = GetReader();
1445                     PositionOnNodeType(DataReader, XmlNodeType.Whitespace);
1446                     bPassed = TestLog.Equals(DataReader.BaseURI, String.Empty, Variation.Desc);
1447                     BoolToLTMResult(bPassed);
1448                 }
1449 
1450                 //[Variation("BaseURI for EndElement node")]
TestBaseURI10()1451                 public void TestBaseURI10()
1452                 {
1453                     bool bPassed = false;
1454                     XmlReader DataReader = GetReader();
1455                     PositionOnNodeType(DataReader, XmlNodeType.EndElement);
1456                     bPassed = TestLog.Equals(DataReader.BaseURI, String.Empty, Variation.Desc);
1457                     BoolToLTMResult(bPassed);
1458                 }
1459 
1460                 //[Variation("BaseURI for external General Entity")]
TestTextReaderBaseURI4()1461                 public void TestTextReaderBaseURI4()
1462                 {
1463                     bool bPassed = false;
1464                     XmlReader DataReader = GetReader();
1465                     PositionOnElement(DataReader, "ENTITY5");
1466                     DataReader.Read();
1467                     bPassed = TestLog.Equals(DataReader.BaseURI, String.Empty, "Before ResolveEntity");
1468                     bPassed = VerifyNode(DataReader, XmlNodeType.Text, String.Empty, ST_GEN_ENT_VALUE) && bPassed;
1469                     bPassed = TestLog.Equals(DataReader.BaseURI, String.Empty, "After ResolveEntity");
1470                     BoolToLTMResult(bPassed);
1471                 }
1472             }
1473         }
1474     }
1475 }
1476