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 > 1357 fffffffffffffffffffffffffffffffffffffff 1358 fffffffffffffffffffffffffffffffffffffff 1359 fffffffffffffffffffffffffffffffffffffff 1360 fffffffffffffffffffffffffffffffffffffff 1361 fffffffffffffffffffffffffffffffffffffff 1362 fffffffffffffffffffffffffffffffffffffff 1363 fffffffffffffffffffffffffffffffffffffff 1364 fffffffffffffffffffffffffffffffffffffff 1365 & 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