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 using XmlCoreTest.Common; 10 11 namespace CoreXml.Test.XLinq 12 { 13 public partial class FunctionalTests : TestModule 14 { 15 public partial class XNodeReaderTests : XLinqTestCase 16 { 17 //[TestCase(Name = "ReadValue", Desc = "ReadValue")] 18 public partial class TCReadValue : BridgeHelpers 19 { VerifyInvalidReadValue(int iBufferSize, int iIndex, int iCount, Type exceptionType)20 private bool VerifyInvalidReadValue(int iBufferSize, int iIndex, int iCount, Type exceptionType) 21 { 22 bool bPassed = false; 23 Char[] buffer = new Char[iBufferSize]; 24 25 XmlReader DataReader = GetReader(); 26 PositionOnElement(DataReader, ST_TEST_NAME); 27 DataReader.Read(); 28 if (!DataReader.CanReadValueChunk) 29 { 30 try 31 { 32 DataReader.ReadValueChunk(buffer, 0, 5); 33 return bPassed; 34 } 35 catch (NotSupportedException) 36 { 37 return true; 38 } 39 } 40 try 41 { 42 DataReader.ReadValueChunk(buffer, iIndex, iCount); 43 } 44 catch (Exception e) 45 { 46 bPassed = (e.GetType().ToString() == exceptionType.ToString()); 47 if (!bPassed) 48 { 49 TestLog.WriteLine("Actual exception:{0}", e.GetType().ToString()); 50 TestLog.WriteLine("Expected exception:{0}", exceptionType.ToString()); 51 } 52 } 53 54 return bPassed; 55 } 56 57 //[Variation("ReadValue", Priority = 0)] TestReadValuePri0()58 public void TestReadValuePri0() 59 { 60 char[] buffer = new char[5]; 61 XmlReader DataReader = GetReader(new StringReader("<root>value</root>")); 62 PositionOnElement(DataReader, "root"); 63 DataReader.Read(); 64 65 if (!DataReader.CanReadValueChunk) 66 { 67 try 68 { 69 DataReader.ReadValueChunk(buffer, 0, 5); 70 throw new TestException(TestResult.Failed, ""); 71 } 72 catch (NotSupportedException) 73 { 74 return; 75 } 76 } 77 78 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 5), 5, "Didn't read 5 chars"); 79 TestLog.Compare("value", new string(buffer), "Strings don't match"); 80 } 81 82 //[Variation("ReadValue on Element", Priority = 0)] TestReadValuePri0onElement()83 public void TestReadValuePri0onElement() 84 { 85 char[] buffer = new char[5]; 86 XmlReader DataReader = GetReader(new StringReader("<root>value</root>")); 87 PositionOnElement(DataReader, "root"); 88 89 if (!DataReader.CanReadValueChunk) 90 { 91 try 92 { 93 DataReader.ReadValueChunk(buffer, 0, 5); 94 throw new TestException(TestResult.Failed, ""); 95 } 96 catch (NotSupportedException) 97 { 98 return; 99 } 100 } 101 102 try 103 { 104 DataReader.ReadValueChunk(buffer, 0, 5); 105 } 106 catch (InvalidOperationException) 107 { 108 return; 109 } 110 111 throw new TestFailedException("ReadValue didn't throw expected exception"); 112 } 113 114 //[Variation("ReadValue on Attribute", Priority = 0)] TestReadValueOnAttribute0()115 public void TestReadValueOnAttribute0() 116 { 117 char[] buffer = new char[5]; 118 XmlReader DataReader = GetReader(new StringReader("<root name=\"value\">value</root>")); 119 PositionOnElement(DataReader, "root"); 120 DataReader.MoveToNextAttribute(); 121 122 if (!DataReader.CanReadValueChunk) 123 { 124 try 125 { 126 DataReader.ReadValueChunk(buffer, 0, 5); 127 throw new TestException(TestResult.Failed, ""); 128 } 129 catch (NotSupportedException) 130 { 131 return; 132 } 133 } 134 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 5), 5, "Didn't read 5 chars"); 135 TestLog.Compare("value", new string(buffer), "Strings don't match"); 136 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 5), 0, "Did read 5 chars"); 137 } 138 139 //[Variation("ReadValue on Attribute after ReadAttributeValue", Priority = 2)] TestReadValueOnAttribute1()140 public void TestReadValueOnAttribute1() 141 { 142 char[] buffer = new char[5]; 143 XmlReader DataReader = GetReader(new StringReader("<root name=\"value\">value</root>")); 144 PositionOnElement(DataReader, "root"); 145 // This takes to text node of attribute. 146 DataReader.MoveToNextAttribute(); 147 148 if (!DataReader.CanReadValueChunk) 149 { 150 try 151 { 152 DataReader.ReadValueChunk(buffer, 0, 5); 153 throw new TestException(TestResult.Failed, ""); 154 } 155 catch (NotSupportedException) 156 { 157 return; 158 } 159 } 160 TestLog.Compare(DataReader.ReadAttributeValue(), true, "Didn't read attribute value"); 161 TestLog.Compare(DataReader.Value, "value", "Didn't read correct attribute value"); 162 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 5), 5, "Didn't read 5 chars"); 163 TestLog.Compare("value", new string(buffer), "Strings don't match"); 164 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 5), 0, "Did read 5 chars"); 165 DataReader.MoveToElement(); 166 DataReader.Read(); 167 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 5), 5, "Didn't read 5 chars on text node"); 168 TestLog.Compare("value", new string(buffer), "Strings don't match"); 169 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 5), 0, "Did read 5 chars on text node"); 170 } 171 172 //[Variation("ReadValue on empty buffer", Priority = 0)] TestReadValue2Pri0()173 public void TestReadValue2Pri0() 174 { 175 char[] buffer = new char[0]; 176 XmlReader DataReader = GetReader(new StringReader("<root>value</root>")); 177 PositionOnElement(DataReader, "root"); 178 DataReader.Read(); 179 180 if (!DataReader.CanReadValueChunk) 181 { 182 try 183 { 184 DataReader.ReadValueChunk(buffer, 0, 5); 185 throw new TestException(TestResult.Failed, ""); 186 } 187 catch (NotSupportedException) 188 { 189 return; 190 } 191 } 192 193 try 194 { 195 DataReader.ReadValueChunk(buffer, 0, 5); 196 } 197 catch (ArgumentException) 198 { 199 return; 200 } 201 202 throw new TestFailedException("ReadValue didn't throw expected exception"); 203 } 204 205 //[Variation("ReadValue on negative count", Priority = 0)] TestReadValue3Pri0()206 public void TestReadValue3Pri0() 207 { 208 char[] buffer = new char[5]; 209 XmlReader DataReader = GetReader(new StringReader("<root>value</root>")); 210 PositionOnElement(DataReader, "root"); 211 DataReader.Read(); 212 if (!DataReader.CanReadValueChunk) 213 { 214 try 215 { 216 DataReader.ReadValueChunk(buffer, 0, -1); 217 throw new TestException(TestResult.Failed, ""); 218 } 219 catch (NotSupportedException) 220 { 221 return; 222 } 223 } 224 225 try 226 { 227 DataReader.ReadValueChunk(buffer, 0, -1); 228 } 229 catch (ArgumentOutOfRangeException) 230 { 231 return; 232 } 233 234 throw new TestFailedException("ReadValue didn't throw expected exception"); 235 } 236 237 //[Variation("ReadValue on negative offset", Priority = 0)] TestReadValue4Pri0()238 public void TestReadValue4Pri0() 239 { 240 char[] buffer = new char[5]; 241 XmlReader DataReader = GetReader(new StringReader("<root>value</root>")); 242 PositionOnElement(DataReader, "root"); 243 DataReader.Read(); 244 if (!DataReader.CanReadValueChunk) 245 { 246 try 247 { 248 DataReader.ReadValueChunk(buffer, -1, 5); 249 throw new TestException(TestResult.Failed, ""); 250 } 251 catch (NotSupportedException) 252 { 253 return; 254 } 255 } 256 try 257 { 258 DataReader.ReadValueChunk(buffer, -1, 5); 259 } 260 catch (ArgumentOutOfRangeException) 261 { 262 return; 263 } 264 265 throw new TestFailedException("ReadValue didn't throw expected exception"); 266 } 267 268 //[Variation("ReadValue with buffer = element content / 2", Priority = 0)] TestReadValue1()269 public void TestReadValue1() 270 { 271 Char[] buffer = new Char[5]; 272 273 XmlReader DataReader = GetReader(); 274 PositionOnElement(DataReader, ST_TEST_NAME); 275 DataReader.Read(); 276 277 if (!DataReader.CanReadValueChunk) 278 { 279 try 280 { 281 DataReader.ReadValueChunk(buffer, 0, 5); 282 throw new TestException(TestResult.Failed, ""); 283 } 284 catch (NotSupportedException) 285 { 286 return; 287 } 288 } 289 290 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 5), 5, "Didn't read first 5"); 291 TestLog.Compare("01234", new string(buffer), "First strings don't match"); 292 293 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 5), 5, "Didn't read second 5 chars"); 294 TestLog.Compare("56789", new string(buffer), "Second strings don't match"); 295 } 296 297 //[Variation("ReadValue entire value in one call", Priority = 0)] TestReadValue2()298 public void TestReadValue2() 299 { 300 Char[] buffer = new Char[10]; 301 302 XmlReader DataReader = GetReader(); 303 PositionOnElement(DataReader, ST_TEST_NAME); 304 DataReader.Read(); 305 if (!DataReader.CanReadValueChunk) 306 { 307 try 308 { 309 DataReader.ReadValueChunk(buffer, 0, 5); 310 throw new TestException(TestResult.Failed, ""); 311 } 312 catch (NotSupportedException) 313 { 314 return; 315 } 316 } 317 318 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 10), 10, "Didn't read 10"); 319 TestLog.Compare("0123456789", new string(buffer), "Strings don't match"); 320 } 321 322 //[Variation("ReadValue bit by bit", Priority = 0)] TestReadValue3()323 public void TestReadValue3() 324 { 325 Char[] buffer = new Char[10]; 326 327 XmlReader DataReader = GetReader(); 328 PositionOnElement(DataReader, ST_TEST_NAME); 329 DataReader.Read(); 330 if (!DataReader.CanReadValueChunk) 331 { 332 try 333 { 334 DataReader.ReadValueChunk(buffer, 0, 5); 335 throw new TestException(TestResult.Failed, ""); 336 } 337 catch (NotSupportedException) 338 { 339 return; 340 } 341 } 342 343 int index = 0; 344 345 for (index = 0; index < buffer.Length; index++) 346 { 347 TestLog.Compare(DataReader.ReadValueChunk(buffer, index, 1), 1, "Read " + index); 348 } 349 350 TestLog.Compare("0123456789", new string(buffer), "Strings don't match"); 351 } 352 353 //[Variation("ReadValue for value more than 4K", Priority = 0)] TestReadValue4()354 public void TestReadValue4() 355 { 356 int size = 8192; 357 Char[] buffer = new Char[size]; 358 359 string val = new string('x', size); 360 361 XmlReader DataReader = GetReader(new StringReader("<root>" + val + "</root>")); 362 PositionOnElement(DataReader, "root"); 363 DataReader.Read(); 364 365 if (!DataReader.CanReadValueChunk) 366 { 367 try 368 { 369 DataReader.ReadValueChunk(buffer, 0, 5); 370 throw new TestException(TestResult.Failed, ""); 371 } 372 catch (NotSupportedException) 373 { 374 return; 375 } 376 } 377 int index = 0; 378 for (index = 0; index < buffer.Length; index++) 379 { 380 TestLog.Compare(DataReader.ReadValueChunk(buffer, index, 1), 1, "Read " + index); 381 } 382 383 TestLog.Compare(val, new string(buffer), "Strings don't match"); 384 } 385 386 //[Variation("ReadValue for value more than 4K and invalid element", Priority = 1)] TestReadValue5()387 public void TestReadValue5() 388 { 389 int size = 8192; 390 Char[] buffer = new Char[size]; 391 string val = new string('x', size); 392 try 393 { 394 XmlReader DataReader = GetReader(new StringReader("<root>" + val + "</notroot>")); 395 PositionOnElement(DataReader, "root"); 396 DataReader.Read(); 397 if (!DataReader.CanReadValueChunk) 398 { 399 try 400 { 401 DataReader.ReadValueChunk(buffer, 0, 5); 402 throw new TestException(TestResult.Failed, ""); 403 } 404 catch (NotSupportedException) 405 { 406 return; 407 } 408 } 409 int index = 0; 410 for (index = 0; index < buffer.Length; index++) 411 { 412 TestLog.Compare(DataReader.ReadValueChunk(buffer, index, 1), 1, "Read " + index); 413 } 414 TestLog.Compare(val, new string(buffer), "Strings don't match"); 415 DataReader.Read(); 416 throw new TestException(TestResult.Failed, ""); 417 } 418 catch (XmlException) 419 { 420 return; 421 } 422 } 423 424 //[Variation("ReadValue with Entity Reference, EntityHandling = ExpandEntities")] TestReadValue6()425 public void TestReadValue6() 426 { 427 string strExpected = ST_IGNORE_ENTITIES; 428 Char[] buffer = new Char[strExpected.Length]; 429 430 XmlReader DataReader = GetReader(); 431 PositionOnElement(DataReader, ST_ENTTEST_NAME); 432 DataReader.Read(); 433 if (!DataReader.CanReadValueChunk) 434 { 435 try 436 { 437 DataReader.ReadValueChunk(buffer, 0, 5); 438 throw new TestException(TestResult.Failed, ""); 439 } 440 catch (NotSupportedException) 441 { 442 return; 443 } 444 } 445 446 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, strExpected.Length), strExpected.Length, "ReadValue1"); 447 TestLog.Compare(new string(buffer), strExpected, "Str1"); 448 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 1), 0, "ReadValue2"); 449 TestLog.Compare(VerifyNode(DataReader, XmlNodeType.Element, "ENTITY2", String.Empty), "Verify"); 450 } 451 452 //[Variation("ReadValue with count > buffer size")] TestReadValue7()453 public void TestReadValue7() 454 { 455 BoolToLTMResult(VerifyInvalidReadValue(5, 0, 6, typeof(ArgumentOutOfRangeException))); 456 } 457 458 //[Variation("ReadValue with index > buffer size")] TestReadValue8()459 public void TestReadValue8() 460 { 461 BoolToLTMResult(VerifyInvalidReadValue(5, 5, 1, typeof(ArgumentOutOfRangeException))); 462 } 463 464 //[Variation("ReadValue with index + count exceeds buffer")] TestReadValue10()465 public void TestReadValue10() 466 { 467 BoolToLTMResult(VerifyInvalidReadValue(5, 2, 5, typeof(ArgumentOutOfRangeException))); 468 } 469 470 //[Variation("ReadValue with combination Text, CDATA and Whitespace")] TestReadChar11()471 public void TestReadChar11() 472 { 473 string strExpected = "AB"; 474 XmlReader DataReader = GetReader(); 475 476 PositionOnElement(DataReader, "CAT"); 477 DataReader.Read(); 478 479 char[] buffer = new char[strExpected.Length]; 480 if (!DataReader.CanReadValueChunk) 481 { 482 try 483 { 484 DataReader.ReadValueChunk(buffer, 0, 5); 485 throw new TestException(TestResult.Failed, ""); 486 } 487 catch (NotSupportedException) 488 { 489 return; 490 } 491 } 492 493 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, buffer.Length), strExpected.Length, "ReadValue"); 494 TestLog.Compare(new string(buffer), strExpected, "str"); 495 } 496 497 //[Variation("ReadValue with combination Text, CDATA and SignificantWhitespace")] TestReadChar12()498 public void TestReadChar12() 499 { 500 string strExpected = "AB"; 501 XmlReader DataReader = GetReader(); 502 503 PositionOnElement(DataReader, "CATMIXED"); 504 DataReader.Read(); 505 char[] buffer = new char[strExpected.Length]; 506 if (!DataReader.CanReadValueChunk) 507 { 508 try 509 { 510 DataReader.ReadValueChunk(buffer, 0, 5); 511 throw new TestException(TestResult.Failed, ""); 512 } 513 catch (NotSupportedException) 514 { 515 return; 516 } 517 } 518 519 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, buffer.Length), strExpected.Length, "ReadValue"); 520 TestLog.Compare(new string(buffer), strExpected, "str"); 521 } 522 523 //[Variation("ReadValue with buffer == null")] TestReadChar13()524 public void TestReadChar13() 525 { 526 XmlReader DataReader = GetReader(); 527 528 PositionOnElement(DataReader, "CHARS1"); 529 DataReader.Read(); 530 if (!DataReader.CanReadValueChunk) 531 { 532 try 533 { 534 DataReader.ReadValueChunk(null, 0, 5); 535 throw new TestException(TestResult.Failed, ""); 536 } 537 catch (NotSupportedException) 538 { 539 return; 540 } 541 } 542 543 try 544 { 545 DataReader.ReadValueChunk(null, 0, 0); 546 } 547 catch (ArgumentNullException) 548 { 549 return; 550 } 551 552 throw new TestException(TestResult.Failed, ""); 553 } 554 555 //[Variation("ReadValue with multiple different inner nodes")] TestReadChar14()556 public void TestReadChar14() 557 { 558 string strExpected = "somevalue"; 559 char[] buffer = new char[strExpected.Length]; 560 string strxml = "<ROOT>somevalue<![CDATA[somevalue]]>somevalue</ROOT>"; 561 XmlReader DataReader = GetReaderStr(strxml); 562 PositionOnElement(DataReader, "ROOT"); 563 564 DataReader.Read(); 565 if (!DataReader.CanReadValueChunk) 566 { 567 try 568 { 569 DataReader.ReadValueChunk(buffer, 0, 5); 570 throw new TestException(TestResult.Failed, ""); 571 } 572 catch (NotSupportedException) 573 { 574 return; 575 } 576 } 577 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, buffer.Length), strExpected.Length, "ReadValue1"); 578 TestLog.Compare(new string(buffer), strExpected, "str1"); 579 580 // Now on CDATA. 581 DataReader.Read(); 582 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, buffer.Length), strExpected.Length, "ReadValue2"); 583 TestLog.Compare(new string(buffer), strExpected, "str2"); 584 585 // Now back on Text 586 DataReader.Read(); 587 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, buffer.Length), strExpected.Length, "ReadValue3"); 588 TestLog.Compare(new string(buffer), strExpected, "str3"); 589 } 590 591 //[Variation("ReadValue after failed ReadValue")] TestReadChar15()592 public void TestReadChar15() 593 { 594 string strExpected = "somevalue"; 595 char[] buffer = new char[strExpected.Length]; 596 string strxml = "<ROOT>somevalue</ROOT>"; 597 XmlReader DataReader = GetReaderStr(strxml); 598 PositionOnElement(DataReader, "ROOT"); 599 DataReader.Read(); 600 if (!DataReader.CanReadValueChunk) 601 { 602 try 603 { 604 DataReader.ReadValueChunk(buffer, 0, 5); 605 throw new TestException(TestResult.Failed, ""); 606 } 607 catch (NotSupportedException) 608 { 609 return; 610 } 611 } 612 613 int nChars; 614 try 615 { 616 nChars = DataReader.ReadValueChunk(buffer, strExpected.Length, 3); 617 } 618 catch (ArgumentException) 619 { 620 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, buffer.Length), strExpected.Length, "ReadValue Count"); 621 TestLog.Compare(new string(buffer), strExpected, "str"); 622 return; 623 } 624 625 TestLog.WriteLine("Couldn't read after ArgumentException"); 626 throw new TestException(TestResult.Failed, ""); 627 } 628 629 //[Variation("Read after partial ReadValue")] TestReadChar16()630 public void TestReadChar16() 631 { 632 string strExpected = "somevalue"; 633 char[] buffer = new char[strExpected.Length]; 634 string strxml = "<ROOT>somevalue</ROOT>"; 635 XmlReader DataReader = GetReaderStr(strxml); 636 PositionOnElement(DataReader, "ROOT"); 637 DataReader.Read(); 638 if (!DataReader.CanReadValueChunk) 639 { 640 try 641 { 642 DataReader.ReadValueChunk(buffer, 0, 5); 643 throw new TestException(TestResult.Failed, ""); 644 } 645 catch (NotSupportedException) 646 { 647 return; 648 } 649 } 650 651 int nChars = DataReader.ReadValueChunk(buffer, 0, 2); 652 TestLog.Compare(nChars, 2, "Read 2"); 653 DataReader.Read(); 654 TestLog.Compare(VerifyNode(DataReader, XmlNodeType.EndElement, "ROOT", String.Empty), "1vn"); 655 } 656 657 //[Variation("Test error after successful ReadValue")] TestReadChar19()658 public void TestReadChar19() 659 { 660 Char[] buffer = new Char[9]; 661 try 662 { 663 XmlReader DataReader = GetReaderStr("<root>somevalue</root></root>"); 664 PositionOnElement(DataReader, "root"); 665 DataReader.Read(); 666 if (!DataReader.CanReadValueChunk) 667 { 668 try 669 { 670 DataReader.ReadValueChunk(buffer, 0, 5); 671 throw new TestException(TestResult.Failed, ""); 672 } 673 catch (NotSupportedException) 674 { 675 return; 676 } 677 } 678 int index = 0; 679 for (index = 0; index < buffer.Length; index++) 680 { 681 TestLog.Compare(DataReader.ReadValueChunk(buffer, index, 1), 1, "Read " + index); 682 } 683 TestLog.Compare("somevalue", new string(buffer), "Strings don't match"); 684 while (DataReader.Read()) ; 685 } 686 catch (XmlException) 687 { 688 return; 689 } 690 throw new TestException(TestResult.Failed, ""); 691 } 692 693 //[Variation("Call on invalid element content after 4k boundary", Priority = 1)] TestReadChar21()694 public void TestReadChar21() 695 { 696 string somechar = new string('x', 5000); 697 string strxml = String.Format("<ROOT>a" + somechar + "{0}c</ROOT>", Convert.ToChar(0)); 698 try 699 { 700 XmlReader DataReader = GetReaderStr(strxml); 701 PositionOnElement(DataReader, "ROOT"); 702 char[] buffer = new char[1]; 703 if (!DataReader.CanReadValueChunk) 704 { 705 try 706 { 707 DataReader.ReadValueChunk(buffer, 0, 5); 708 throw new TestException(TestResult.Failed, ""); 709 } 710 catch (NotSupportedException) 711 { 712 return; 713 } 714 } 715 DataReader.Read(); 716 while (DataReader.ReadValueChunk(buffer, 0, 1) > 0) ; 717 } 718 catch (XmlException) 719 { 720 return; 721 } 722 723 throw new TestException(TestResult.Failed, ""); 724 } 725 726 //[Variation("ReadValue with whitespace")] TestTextReadValue25()727 public void TestTextReadValue25() 728 { 729 string strExpected = "somevalue"; 730 char[] buffer = new char[strExpected.Length]; 731 string strxml = "<ROOT>somevalue<![CDATA[somevalue]]><test1/> <test2/></ROOT>"; 732 XmlReader DataReader = GetReaderStr(strxml); 733 PositionOnElement(DataReader, "ROOT"); 734 735 DataReader.Read(); 736 if (!DataReader.CanReadValueChunk) 737 { 738 try 739 { 740 DataReader.ReadValueChunk(buffer, 0, 5); 741 throw new TestException(TestResult.Failed, ""); 742 } 743 catch (NotSupportedException) 744 { 745 return; 746 } 747 } 748 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, buffer.Length), strExpected.Length, "ReadValue1"); 749 TestLog.Compare(new string(buffer), strExpected, "str1"); 750 751 // Now on CDATA. 752 DataReader.Read(); 753 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, buffer.Length), strExpected.Length, "ReadValue2"); 754 TestLog.Compare(new string(buffer), strExpected, "str2"); 755 756 // Now on test 757 DataReader.Read(); 758 759 char[] spaces = new char[4]; 760 // Now on whitespace. 761 DataReader.Read(); 762 TestLog.Compare(DataReader.ReadValueChunk(spaces, 0, spaces.Length), spaces.Length, "ReadValue3"); 763 TestLog.Compare(new string(spaces), " ", "str3"); 764 } 765 766 //[Variation("ReadValue when end tag doesn't exist")] TestTextReadValue26()767 public void TestTextReadValue26() 768 { 769 char[] buffer = new char[5]; 770 try 771 { 772 XmlReader DataReader = GetReaderStr("<root>value</notroot>"); 773 PositionOnElement(DataReader, "root"); 774 DataReader.Read(); 775 if (!DataReader.CanReadValueChunk) 776 { 777 try 778 { 779 DataReader.ReadValueChunk(buffer, 0, 5); 780 throw new TestException(TestResult.Failed, ""); 781 } 782 catch (NotSupportedException) 783 { 784 return; 785 } 786 } 787 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 5), 5, "Didn't read 5 chars"); 788 TestLog.Compare("value", new string(buffer), "Strings don't match"); 789 DataReader.Read(); 790 throw new TestException(TestResult.Failed, ""); 791 } 792 catch (XmlException) 793 { 794 return; 795 } 796 } 797 798 //[Variation("Testing with character entities")] TestCharEntities0()799 public void TestCharEntities0() 800 { 801 char[] buffer = new char[1]; 802 XmlReader DataReader = GetReaderStr("<root>va</root>lue</root>"); 803 PositionOnElement(DataReader, "root"); 804 DataReader.Read(); 805 if (!DataReader.CanReadValueChunk) 806 { 807 try 808 { 809 DataReader.ReadValueChunk(buffer, 0, 5); 810 throw new TestException(TestResult.Failed, ""); 811 } 812 catch (NotSupportedException) 813 { 814 return; 815 } 816 } 817 818 while (DataReader.ReadValueChunk(buffer, 0, 1) > 0) ; 819 820 DataReader.Read(); 821 DataReader.Read(); 822 823 TestLog.Compare(DataReader.NodeType, XmlNodeType.None, "Not on End"); 824 } 825 826 //[Variation("Testing with character entities when value more than 4k")] TestCharEntities1()827 public void TestCharEntities1() 828 { 829 char[] buffer = new char[1]; 830 XmlReader DataReader = GetReaderStr("<root>va" + new string('x', 5000) + "l</root>ue</root>"); 831 832 DataReader.Read(); 833 if (!DataReader.CanReadValueChunk) 834 { 835 try 836 { 837 DataReader.ReadValueChunk(buffer, 0, 5); 838 throw new TestException(TestResult.Failed, ""); 839 } 840 catch (NotSupportedException) 841 { 842 return; 843 } 844 } 845 846 while (DataReader.ReadValueChunk(buffer, 0, 1) > 0) ; 847 848 DataReader.Read(); 849 DataReader.Read(); 850 851 TestLog.Compare(DataReader.NodeType, XmlNodeType.None, "Not on End"); 852 } 853 854 //[Variation("Testing with character entities with another pattern")] TestCharEntities2()855 public void TestCharEntities2() 856 { 857 char[] buffer = new char[1]; 858 XmlReader DataReader = GetReaderStr("<!DOCTYPE root[<!ENTITY x \"somevalue\"><!ELEMENT root ANY>]><root>value&x;</root>"); 859 860 DataReader.Read(); 861 if (!DataReader.CanReadValueChunk) 862 { 863 try 864 { 865 DataReader.ReadValueChunk(buffer, 0, 5); 866 throw new TestException(TestResult.Failed, ""); 867 } 868 catch (NotSupportedException) 869 { 870 return; 871 } 872 } 873 874 while (DataReader.ReadValueChunk(buffer, 0, 1) > 0) ; 875 876 DataReader.Read(); 877 DataReader.Read(); 878 879 TestLog.Compare(DataReader.NodeType, XmlNodeType.None, "Not on End"); 880 } 881 882 //[Variation("Testing a use case pattern with large file")] TestReadValueOnBig()883 public void TestReadValueOnBig() 884 { 885 XmlReader DataReader = GetReader(); 886 887 char[] buffer = new char[1]; 888 while (DataReader.Read()) 889 { 890 if (DataReader.HasValue && DataReader.CanReadValueChunk) 891 { 892 Random rand = new Random(); 893 894 int count; 895 do 896 { 897 count = rand.Next(4) + 1; 898 buffer = new char[count]; 899 if (rand.Next(1) == 1) 900 { 901 break; 902 } 903 } 904 while (DataReader.ReadValueChunk(buffer, 0, count) > 0); 905 } 906 else 907 { 908 if (!DataReader.CanReadValueChunk) 909 { 910 try 911 { 912 buffer = new char[1]; 913 DataReader.ReadValueChunk(buffer, 0, 1); 914 } 915 catch (NotSupportedException) 916 { 917 } 918 } 919 else 920 { 921 try 922 { 923 buffer = new char[1]; 924 DataReader.ReadValueChunk(buffer, 0, 1); 925 } 926 catch (InvalidOperationException) 927 { 928 } 929 } 930 } 931 } 932 } 933 934 //[Variation("ReadValue on Comments with IgnoreComments")] TestReadValueOnComments0()935 public void TestReadValueOnComments0() 936 { 937 char[] buffer = null; 938 buffer = new char[3]; 939 XmlReaderSettings settings = new XmlReaderSettings(); 940 settings.IgnoreComments = true; 941 XmlReader DataReader = GetReaderStr("<root>val<!--Comment-->ue</root>"); 942 943 DataReader.Read(); 944 try 945 { 946 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 3), 3, "Didn't read 3 chars"); 947 throw new TestException(TestResult.Failed, ""); 948 } 949 catch (NotSupportedException) { } 950 951 buffer = new char[2]; 952 DataReader.Read(); 953 try 954 { 955 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 2), 2, "Didn't read 2 chars"); 956 throw new TestException(TestResult.Failed, ""); 957 } 958 catch (NotSupportedException) { } 959 960 while (DataReader.Read()) ; 961 DataReader.Dispose(); 962 } 963 964 //[Variation("ReadValue on PI with IgnorePI")] TestReadValueOnPIs0()965 public void TestReadValueOnPIs0() 966 { 967 char[] buffer = null; 968 buffer = new char[3]; 969 970 XmlReader DataReader = GetReaderStr("<root>val<?pi target?>ue</root>"); 971 DataReader.Read(); 972 try 973 { 974 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 3), 3, "Didn't read 3 chars"); 975 throw new TestException(TestResult.Failed, ""); 976 } 977 catch (NotSupportedException) { } 978 979 buffer = new char[2]; 980 DataReader.Read(); 981 try 982 { 983 TestLog.Compare(DataReader.ReadValueChunk(buffer, 0, 2), 2, "Didn't read 2 chars"); 984 throw new TestException(TestResult.Failed, ""); 985 } 986 catch (NotSupportedException) { } 987 988 while (DataReader.Read()) ; 989 DataReader.Dispose(); 990 } 991 992 //[Variation("Skip after ReadAttributeValue/ReadValueChunk")] bug340158()993 public void bug340158() 994 { 995 XmlReaderSettings settings = new XmlReaderSettings(); 996 settings.DtdProcessing = DtdProcessing.Ignore; 997 XmlReader r = XmlReader.Create(FilePathUtil.getStream(Path.Combine("StandardTests", "XML10", "ms_xml", "vs084.xml")), settings); 998 XmlReader reader = GetReader(r); 999 reader.ReadToFollowing("a"); 1000 reader.MoveToNextAttribute(); 1001 reader.ReadAttributeValue(); 1002 try 1003 { 1004 reader.ReadValueChunk(new char[3], 0, 3); 1005 throw new TestException(TestResult.Failed, ""); 1006 } 1007 catch (NotSupportedException) { } 1008 reader.Skip(); 1009 TestLog.Compare(reader.NodeType, XmlNodeType.Text, "NT"); 1010 reader.Read(); 1011 TestLog.Compare(reader.NodeType, XmlNodeType.Element, "NT1"); 1012 TestLog.Compare(reader.Name, "a", "Name"); 1013 } 1014 } 1015 } 1016 } 1017 } 1018