1 // Licensed to the .NET Foundation under one or more agreements. 2 // The .NET Foundation licenses this file to you under the MIT license. 3 // See the LICENSE file in the project root for more information. 4 5 using Microsoft.Test.ModuleCore; 6 using System; 7 using System.IO; 8 using System.Text; 9 using System.Xml; 10 using XmlCoreTest.Common; 11 12 namespace CoreXml.Test.XLinq 13 { 14 public partial class FunctionalTests : TestModule 15 { 16 17 public partial class XNodeReaderTests : XLinqTestCase 18 { 19 //[TestCase(Name = "ReadContentAsBase64", Desc = "ReadContentAsBase64")] 20 public partial class TCReadContentAsBase64 : BridgeHelpers 21 { 22 public const string ST_ELEM_NAME1 = "ElemAll"; 23 public const string ST_ELEM_NAME2 = "ElemEmpty"; 24 public const string ST_ELEM_NAME3 = "ElemNum"; 25 public const string ST_ELEM_NAME4 = "ElemText"; 26 public const string ST_ELEM_NAME5 = "ElemNumText"; 27 public const string ST_ELEM_NAME6 = "ElemLong"; 28 public const string strTextBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; 29 public const string strNumBase64 = "0123456789+/"; 30 Init()31 public override void Init() 32 { 33 base.Init(); 34 CreateBase64TestFile(pBase64Xml); 35 } 36 Terminate()37 public override void Terminate() 38 { 39 DeleteTestFile(pBase64Xml); 40 base.Terminate(); 41 } 42 VerifyInvalidReadBase64(int iBufferSize, int iIndex, int iCount, Type exceptionType)43 private bool VerifyInvalidReadBase64(int iBufferSize, int iIndex, int iCount, Type exceptionType) 44 { 45 bool bPassed = false; 46 byte[] buffer = new byte[iBufferSize]; 47 48 XmlReader DataReader = GetReader(pBase64Xml); 49 PositionOnElement(DataReader, ST_ELEM_NAME1); 50 DataReader.Read(); 51 if (!DataReader.CanReadBinaryContent) return true; 52 try 53 { 54 DataReader.ReadContentAsBase64(buffer, iIndex, iCount); 55 } 56 catch (Exception e) 57 { 58 bPassed = (e.GetType().ToString() == exceptionType.ToString()); 59 60 if (!bPassed) 61 { 62 TestLog.WriteLine("Actual exception:{0}", e.GetType().ToString()); 63 TestLog.WriteLine("Expected exception:{0}", exceptionType.ToString()); 64 } 65 } 66 67 return bPassed; 68 } 69 TestOnInvalidNodeType(XmlNodeType nt)70 protected void TestOnInvalidNodeType(XmlNodeType nt) 71 { 72 XmlReader DataReader = GetReader(pBase64Xml); 73 PositionOnNodeType(DataReader, nt); 74 if (!DataReader.CanReadBinaryContent) return; 75 try 76 { 77 byte[] buffer = new byte[1]; 78 int nBytes = DataReader.ReadContentAsBase64(buffer, 0, 1); 79 } 80 catch (InvalidOperationException ioe) 81 { 82 if (ioe.ToString().IndexOf(nt.ToString()) < 0) 83 TestLog.Compare(false, "Call threw wrong invalid operation exception on " + nt); 84 else 85 return; 86 } 87 TestLog.Compare(false, "Call succeeded on " + nt); 88 } 89 TestOnNopNodeType(XmlNodeType nt)90 protected void TestOnNopNodeType(XmlNodeType nt) 91 { 92 XmlReader DataReader = GetReader(pBase64Xml); 93 94 PositionOnNodeType(DataReader, nt); 95 string name = DataReader.Name; 96 string value = DataReader.Value; 97 if (!DataReader.CanReadBinaryContent) return; 98 99 byte[] buffer = new byte[1]; 100 int nBytes = DataReader.ReadContentAsBase64(buffer, 0, 1); 101 TestLog.Compare(nBytes, 0, "nBytes"); 102 TestLog.Compare(VerifyNode(DataReader, nt, name, value), "vn"); 103 } 104 105 //[Variation("ReadBase64 Element with all valid value")] TestReadBase64_1()106 public void TestReadBase64_1() 107 { 108 int base64len = 0; 109 byte[] base64 = new byte[1000]; 110 111 XmlReader DataReader = GetReader(pBase64Xml); 112 PositionOnElement(DataReader, ST_ELEM_NAME1); 113 DataReader.Read(); 114 if (!DataReader.CanReadBinaryContent) return; 115 116 base64len = DataReader.ReadContentAsBase64(base64, 0, base64.Length); 117 118 string strActbase64 = ""; 119 for (int i = 0; i < base64len; i = i + 2) 120 { 121 strActbase64 += System.BitConverter.ToChar(base64, i); 122 } 123 124 TestLog.Compare(strActbase64, (strTextBase64 + strNumBase64), "Compare All Valid Base64"); 125 } 126 127 //[Variation("ReadBase64 Element with all valid Num value", Priority = 0)] TestReadBase64_2()128 public void TestReadBase64_2() 129 { 130 int base64len = 0; 131 byte[] base64 = new byte[1000]; 132 133 XmlReader DataReader = GetReader(pBase64Xml); 134 PositionOnElement(DataReader, ST_ELEM_NAME3); 135 DataReader.Read(); 136 if (!DataReader.CanReadBinaryContent) return; 137 138 base64len = DataReader.ReadContentAsBase64(base64, 0, base64.Length); 139 140 string strActbase64 = ""; 141 for (int i = 0; i < base64len; i = i + 2) 142 { 143 strActbase64 += System.BitConverter.ToChar(base64, i); 144 } 145 146 TestLog.Compare(strActbase64, strNumBase64, "Compare All Valid Base64"); 147 } 148 149 //[Variation("ReadBase64 Element with all valid Text value")] TestReadBase64_3()150 public void TestReadBase64_3() 151 { 152 int base64len = 0; 153 byte[] base64 = new byte[1000]; 154 155 XmlReader DataReader = GetReader(pBase64Xml); 156 PositionOnElement(DataReader, ST_ELEM_NAME4); 157 DataReader.Read(); 158 if (!DataReader.CanReadBinaryContent) return; 159 160 base64len = DataReader.ReadContentAsBase64(base64, 0, base64.Length); 161 162 string strActbase64 = ""; 163 for (int i = 0; i < base64len; i = i + 2) 164 { 165 strActbase64 += System.BitConverter.ToChar(base64, i); 166 } 167 168 TestLog.Compare(strActbase64, strTextBase64, "Compare All Valid Base64"); 169 } 170 171 //[Variation("ReadBase64 Element with all valid value (from concatenation), Priority=0")] TestReadBase64_5()172 public void TestReadBase64_5() 173 { 174 int base64len = 0; 175 byte[] base64 = new byte[1000]; 176 177 XmlReader DataReader = GetReader(pBase64Xml); 178 PositionOnElement(DataReader, ST_ELEM_NAME5); 179 DataReader.Read(); 180 if (!DataReader.CanReadBinaryContent) return; 181 182 base64len = DataReader.ReadContentAsBase64(base64, 0, base64.Length); 183 184 string strActbase64 = ""; 185 for (int i = 0; i < base64len; i = i + 2) 186 { 187 strActbase64 += System.BitConverter.ToChar(base64, i); 188 } 189 190 TestLog.Compare(strActbase64, (strTextBase64 + strNumBase64), "Compare All Valid Base64"); 191 } 192 193 //[Variation("ReadBase64 Element with Long valid value (from concatenation), Priority=0")] TestReadBase64_6()194 public void TestReadBase64_6() 195 { 196 int base64len = 0; 197 byte[] base64 = new byte[2000]; 198 199 XmlReader DataReader = GetReader(pBase64Xml); 200 PositionOnElement(DataReader, ST_ELEM_NAME6); 201 DataReader.Read(); 202 if (!DataReader.CanReadBinaryContent) return; 203 204 base64len = DataReader.ReadContentAsBase64(base64, 0, base64.Length); 205 206 string strActbase64 = ""; 207 for (int i = 0; i < base64len; i = i + 2) 208 { 209 strActbase64 += System.BitConverter.ToChar(base64, i); 210 } 211 212 string strExpbase64 = ""; 213 for (int i = 0; i < 10; i++) 214 strExpbase64 += (strTextBase64 + strNumBase64); 215 216 TestLog.Compare(strActbase64, strExpbase64, "Compare All Valid Base64"); 217 } 218 219 //[Variation("ReadBase64 with count > buffer size")] ReadBase64_7()220 public void ReadBase64_7() 221 { 222 BoolToLTMResult(VerifyInvalidReadBase64(5, 0, 6, typeof(NotSupportedException))); 223 } 224 225 //[Variation("ReadBase64 with count < 0")] ReadBase64_8()226 public void ReadBase64_8() 227 { 228 BoolToLTMResult(VerifyInvalidReadBase64(5, 2, -1, typeof(NotSupportedException))); 229 } 230 231 //[Variation("ReadBase64 with index > buffer size")] ReadBase64_9()232 public void ReadBase64_9() 233 { 234 BoolToLTMResult(VerifyInvalidReadBase64(5, 5, 1, typeof(NotSupportedException))); 235 } 236 237 //[Variation("ReadBase64 with index < 0")] ReadBase64_10()238 public void ReadBase64_10() 239 { 240 BoolToLTMResult(VerifyInvalidReadBase64(5, -1, 1, typeof(NotSupportedException))); 241 } 242 243 //[Variation("ReadBase64 with index + count exceeds buffer")] ReadBase64_11()244 public void ReadBase64_11() 245 { 246 BoolToLTMResult(VerifyInvalidReadBase64(5, 0, 10, typeof(NotSupportedException))); 247 } 248 249 //[Variation("ReadBase64 index & count =0")] ReadBase64_12()250 public void ReadBase64_12() 251 { 252 byte[] buffer = new byte[5]; 253 int iCount = 0; 254 255 XmlReader DataReader = GetReader(pBase64Xml); 256 PositionOnElement(DataReader, ST_ELEM_NAME1); 257 DataReader.Read(); 258 if (!DataReader.CanReadBinaryContent) return; 259 260 iCount = DataReader.ReadContentAsBase64(buffer, 0, 0); 261 262 TestLog.Compare(iCount, 0, "has to be zero"); 263 } 264 265 //[Variation("ReadBase64 Element multiple into same buffer (using offset), Priority=0")] TestReadBase64_13()266 public void TestReadBase64_13() 267 { 268 int base64len = 20; 269 byte[] base64 = new byte[base64len]; 270 271 XmlReader DataReader = GetReader(pBase64Xml); 272 PositionOnElement(DataReader, ST_ELEM_NAME4); 273 DataReader.Read(); 274 if (!DataReader.CanReadBinaryContent) return; 275 276 string strActbase64 = ""; 277 for (int i = 0; i < base64len; i = i + 2) 278 { 279 DataReader.ReadContentAsBase64(base64, i, 2); 280 strActbase64 = (System.BitConverter.ToChar(base64, i)).ToString(); 281 TestLog.Compare(String.Compare(strActbase64, 0, strTextBase64, i / 2, 1), 0, "Compare All Valid Base64"); 282 } 283 } 284 285 //[Variation("ReadBase64 with buffer == null")] TestReadBase64_14()286 public void TestReadBase64_14() 287 { 288 XmlReader DataReader = GetReader(pBase64Xml); 289 290 PositionOnElement(DataReader, ST_ELEM_NAME4); 291 DataReader.Read(); 292 if (!DataReader.CanReadBinaryContent) return; 293 294 try 295 { 296 DataReader.ReadContentAsBase64(null, 0, 0); 297 } 298 catch (ArgumentNullException) 299 { 300 return; 301 } 302 303 throw new TestException(TestResult.Failed, ""); 304 } 305 306 //[Variation("ReadBase64 after failure")] TestReadBase64_15()307 public void TestReadBase64_15() 308 { 309 XmlReader DataReader = GetReader(pBase64Xml); 310 311 PositionOnElement(DataReader, "ElemErr"); 312 DataReader.Read(); 313 if (!DataReader.CanReadBinaryContent) return; 314 315 316 byte[] buffer = new byte[10]; 317 int nRead = 0; 318 try 319 { 320 nRead = DataReader.ReadContentAsBase64(buffer, 0, 1); 321 throw new TestException(TestResult.Failed, ""); 322 } 323 catch (XmlException e) 324 { 325 CheckXmlException("Xml_InvalidBase64Value", e, 0, 1); 326 } 327 } 328 329 //[Variation("Read after partial ReadBase64", Priority = 0)] TestReadBase64_16()330 public void TestReadBase64_16() 331 { 332 XmlReader DataReader = GetReader(pBase64Xml); 333 334 PositionOnElement(DataReader, "ElemNum"); 335 DataReader.Read(); 336 if (!DataReader.CanReadBinaryContent) return; 337 338 byte[] buffer = new byte[10]; 339 int nRead = DataReader.ReadContentAsBase64(buffer, 0, 8); 340 TestLog.Compare(nRead, 8, "0"); 341 342 DataReader.Read(); 343 344 TestLog.Compare(DataReader.NodeType, XmlNodeType.Element, "1vn"); 345 } 346 347 //[Variation("Current node on multiple calls")] TestReadBase64_17()348 public void TestReadBase64_17() 349 { 350 XmlReader DataReader = GetReader(pBase64Xml); 351 PositionOnElement(DataReader, "ElemNum"); 352 DataReader.Read(); 353 if (!DataReader.CanReadBinaryContent) return; 354 355 byte[] buffer = new byte[30]; 356 357 int nRead = DataReader.ReadContentAsBase64(buffer, 0, 2); 358 TestLog.Compare(nRead, 2, "0"); 359 360 nRead = DataReader.ReadContentAsBase64(buffer, 0, 23); 361 TestLog.Compare(nRead, 22, "1"); 362 363 DataReader.Read(); 364 TestLog.Compare(DataReader.NodeType, XmlNodeType.Element, "Nodetype not end element"); 365 TestLog.Compare(DataReader.Name, "ElemText", "Nodetype not end element"); 366 } 367 368 //[Variation("No op node types")] TestReadBase64_18()369 public void TestReadBase64_18() 370 { 371 TestOnInvalidNodeType(XmlNodeType.EndElement); 372 } 373 374 //[Variation("ReadBase64 with incomplete sequence")] TestTextReadBase64_23()375 public void TestTextReadBase64_23() 376 { 377 byte[] expected = new byte[] { 0, 16, 131, 16, 81 }; 378 379 byte[] buffer = new byte[10]; 380 string strxml = "<r><ROOT>ABCDEFG</ROOT></r>"; 381 XmlReader DataReader = GetReaderStr(strxml); 382 383 PositionOnElement(DataReader, "ROOT"); 384 DataReader.Read(); 385 if (!DataReader.CanReadBinaryContent) return; 386 387 int result = 0; 388 int nRead; 389 while ((nRead = DataReader.ReadContentAsBase64(buffer, result, 1)) > 0) 390 result += nRead; 391 392 TestLog.Compare(result, expected.Length, "res"); 393 for (int i = 0; i < result; i++) 394 TestLog.Compare(buffer[i], expected[i], "buffer[" + i + "]"); 395 } 396 397 //[Variation("ReadBase64 when end tag doesn't exist")] TestTextReadBase64_24()398 public void TestTextReadBase64_24() 399 { 400 byte[] buffer = new byte[5000]; 401 string strxml = "<B>" + new string('c', 5000); 402 try 403 { 404 XmlReader DataReader = GetReaderStr(strxml); 405 PositionOnElement(DataReader, "B"); 406 DataReader.Read(); 407 if (!DataReader.CanReadBinaryContent) return; 408 409 DataReader.ReadContentAsBase64(buffer, 0, 5000); 410 TestLog.WriteLine("Accepted incomplete element"); 411 throw new TestException(TestResult.Failed, ""); 412 } 413 catch (XmlException e) 414 { 415 CheckXmlException("Xml_UnexpectedEOFInElementContent", e, 1, 5004); 416 } 417 } 418 419 //[Variation("ReadBase64 with whitespace in the mIddle")] TestTextReadBase64_26()420 public void TestTextReadBase64_26() 421 { 422 byte[] buffer = new byte[1]; 423 string strxml = "<abc> AQID B B </abc>"; 424 int nRead; 425 426 XmlReader DataReader = GetReaderStr(strxml); 427 PositionOnElement(DataReader, "abc"); 428 DataReader.Read(); 429 if (!DataReader.CanReadBinaryContent) return; 430 431 for (int i = 0; i < 4; i++) 432 { 433 nRead = DataReader.ReadContentAsBase64(buffer, 0, 1); 434 TestLog.Compare(nRead, 1, "res" + i); 435 TestLog.Compare(buffer[0], (byte)(i + 1), "buffer " + i); 436 } 437 438 nRead = DataReader.ReadContentAsBase64(buffer, 0, 1); 439 TestLog.Compare(nRead, 0, "nRead 0"); 440 } 441 442 //[Variation("ReadBase64 with = in the mIddle")] TestTextReadBase64_27()443 public void TestTextReadBase64_27() 444 { 445 byte[] buffer = new byte[1]; 446 string strxml = "<abc>AQI=ID</abc>"; 447 int nRead; 448 449 XmlReader DataReader = GetReaderStr(strxml); 450 PositionOnElement(DataReader, "abc"); 451 452 DataReader.Read(); 453 if (!DataReader.CanReadBinaryContent) return; 454 455 for (int i = 0; i < 2; i++) 456 { 457 nRead = DataReader.ReadContentAsBase64(buffer, 0, 1); 458 TestLog.Compare(nRead, 1, "res" + i); 459 TestLog.Compare(buffer[0], (byte)(i + 1), "buffer " + i); 460 } 461 462 try 463 { 464 DataReader.ReadContentAsBase64(buffer, 0, 1); 465 TestLog.WriteLine("ReadBase64 with = in the middle succeeded"); 466 throw new TestException(TestResult.Failed, ""); 467 } 468 catch (XmlException e) 469 { 470 CheckXmlException("Xml_InvalidBase64Value", e, 0, 1); 471 } 472 } 473 474 //[Variation("ReadBase64 runs into an Overflow", Params = new object[] { "10000" })] 475 //[Variation("ReadBase64 runs into an Overflow", Params = new object[] { "1000000" })] 476 //[Variation("ReadBase64 runs into an Overflow", Params = new object[] { "10000000" })] RunBase64DoesnNotRunIntoOverflow()477 public void RunBase64DoesnNotRunIntoOverflow() 478 { 479 int totalfilesize = Convert.ToInt32(Variation.Params[0].ToString()); 480 string ascii = new string('c', totalfilesize); 481 482 byte[] bits = Encoding.Unicode.GetBytes(ascii); 483 string base64str = Convert.ToBase64String(bits); 484 485 string fileName = "bug105376_" + Variation.Params[0].ToString() + ".xml"; 486 FilePathUtil.addStream(fileName, new MemoryStream()); 487 StreamWriter sw = new StreamWriter(FilePathUtil.getStream(fileName)); 488 sw.Write("<root><base64>"); 489 sw.Write(base64str); 490 sw.Write("</base64></root>"); 491 sw.Flush(); 492 493 XmlReader DataReader = GetReader(fileName); 494 495 int SIZE = (totalfilesize - 30); 496 int SIZE64 = SIZE * 3 / 4; 497 498 PositionOnElement(DataReader, "base64"); 499 DataReader.Read(); 500 if (!DataReader.CanReadBinaryContent) return; 501 502 byte[] base64 = new byte[SIZE64]; 503 504 int startPos = 0; 505 int readSize = 4096; 506 507 int currentSize = 0; 508 currentSize = DataReader.ReadContentAsBase64(base64, startPos, readSize); 509 TestLog.Compare(currentSize, readSize, "Read other than first chunk"); 510 511 readSize = SIZE64 - readSize; 512 currentSize = DataReader.ReadContentAsBase64(base64, startPos, readSize); 513 TestLog.Compare(currentSize, readSize, "Read other than remaining Chunk Size"); 514 515 readSize = 0; 516 currentSize = DataReader.ReadContentAsBase64(base64, startPos, readSize); 517 TestLog.Compare(currentSize, 0, "Read other than Zero Bytes"); 518 519 DataReader.Dispose(); 520 } 521 } 522 523 //[TestCase(Name = "ReadElementContentAsBase64", Desc = "ReadElementContentAsBase64")] 524 public partial class TCReadElementContentAsBase64 : BridgeHelpers 525 { 526 public const string ST_ELEM_NAME1 = "ElemAll"; 527 public const string ST_ELEM_NAME2 = "ElemEmpty"; 528 public const string ST_ELEM_NAME3 = "ElemNum"; 529 public const string ST_ELEM_NAME4 = "ElemText"; 530 public const string ST_ELEM_NAME5 = "ElemNumText"; 531 public const string ST_ELEM_NAME6 = "ElemLong"; 532 public const string strTextBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; 533 public const string strNumBase64 = "0123456789+/"; 534 Init()535 public override void Init() 536 { 537 base.Init(); 538 CreateBase64TestFile(pBase64Xml); 539 } 540 Terminate()541 public override void Terminate() 542 { 543 DeleteTestFile(pBase64Xml); 544 base.Terminate(); 545 } 546 VerifyInvalidReadBase64(int iBufferSize, int iIndex, int iCount, Type exceptionType)547 private bool VerifyInvalidReadBase64(int iBufferSize, int iIndex, int iCount, Type exceptionType) 548 { 549 bool bPassed = false; 550 byte[] buffer = new byte[iBufferSize]; 551 552 XmlReader DataReader = GetReader(pBase64Xml); 553 PositionOnElement(DataReader, ST_ELEM_NAME1); 554 if (!DataReader.CanReadBinaryContent) return true; 555 556 try 557 { 558 DataReader.ReadContentAsBase64(buffer, iIndex, iCount); 559 } 560 catch (Exception e) 561 { 562 bPassed = (e.GetType().ToString() == exceptionType.ToString()); 563 if (!bPassed) 564 { 565 TestLog.WriteLine("Actual exception:{0}", e.GetType().ToString()); 566 TestLog.WriteLine("Expected exception:{0}", exceptionType.ToString()); 567 } 568 } 569 570 return bPassed; 571 } 572 TestOnInvalidNodeType(XmlNodeType nt)573 protected void TestOnInvalidNodeType(XmlNodeType nt) 574 { 575 XmlReader DataReader = GetReader(pBase64Xml); 576 PositionOnNodeType(DataReader, nt); 577 if (!DataReader.CanReadBinaryContent) return; 578 try 579 { 580 byte[] buffer = new byte[1]; 581 int nBytes = DataReader.ReadElementContentAsBase64(buffer, 0, 1); 582 } 583 catch (InvalidOperationException ioe) 584 { 585 if (ioe.ToString().IndexOf(nt.ToString()) < 0) 586 TestLog.Compare(false, "Call threw wrong invalid operation exception on " + nt); 587 else 588 return; 589 } 590 TestLog.Compare(false, "Call succeeded on " + nt); 591 } 592 593 //[Variation("ReadBase64 Element with all valid value")] TestReadBase64_1()594 public void TestReadBase64_1() 595 { 596 int base64len = 0; 597 byte[] base64 = new byte[1000]; 598 599 XmlReader DataReader = GetReader(pBase64Xml); 600 PositionOnElement(DataReader, ST_ELEM_NAME1); 601 if (!DataReader.CanReadBinaryContent) return; 602 603 base64len = DataReader.ReadElementContentAsBase64(base64, 0, base64.Length); 604 605 string strActbase64 = ""; 606 for (int i = 0; i < base64len; i = i + 2) 607 { 608 strActbase64 += System.BitConverter.ToChar(base64, i); 609 } 610 611 TestLog.Compare(strActbase64, (strTextBase64 + strNumBase64), "Compare All Valid Base64"); 612 } 613 614 //[Variation("ReadBase64 Element with all valid Num value", Priority = 0)] TestReadBase64_2()615 public void TestReadBase64_2() 616 { 617 int base64len = 0; 618 byte[] base64 = new byte[1000]; 619 620 XmlReader DataReader = GetReader(pBase64Xml); 621 PositionOnElement(DataReader, ST_ELEM_NAME3); 622 if (!DataReader.CanReadBinaryContent) return; 623 624 base64len = DataReader.ReadElementContentAsBase64(base64, 0, base64.Length); 625 626 string strActbase64 = ""; 627 for (int i = 0; i < base64len; i = i + 2) 628 { 629 strActbase64 += System.BitConverter.ToChar(base64, i); 630 } 631 632 TestLog.Compare(strActbase64, strNumBase64, "Compare All Valid Base64"); 633 } 634 635 //[Variation("ReadBase64 Element with all valid Text value")] TestReadBase64_3()636 public void TestReadBase64_3() 637 { 638 int base64len = 0; 639 byte[] base64 = new byte[1000]; 640 641 XmlReader DataReader = GetReader(pBase64Xml); 642 PositionOnElement(DataReader, ST_ELEM_NAME4); 643 if (!DataReader.CanReadBinaryContent) return; 644 645 base64len = DataReader.ReadElementContentAsBase64(base64, 0, base64.Length); 646 647 string strActbase64 = ""; 648 for (int i = 0; i < base64len; i = i + 2) 649 { 650 strActbase64 += System.BitConverter.ToChar(base64, i); 651 } 652 653 TestLog.Compare(strActbase64, strTextBase64, "Compare All Valid Base64"); 654 } 655 656 //[Variation("ReadBase64 Element with all valid value (from concatenation), Priority=0")] TestReadBase64_5()657 public void TestReadBase64_5() 658 { 659 int base64len = 0; 660 byte[] base64 = new byte[1000]; 661 662 XmlReader DataReader = GetReader(pBase64Xml); 663 PositionOnElement(DataReader, ST_ELEM_NAME5); 664 if (!DataReader.CanReadBinaryContent) return; 665 666 base64len = DataReader.ReadElementContentAsBase64(base64, 0, base64.Length); 667 668 string strActbase64 = ""; 669 for (int i = 0; i < base64len; i = i + 2) 670 { 671 strActbase64 += System.BitConverter.ToChar(base64, i); 672 } 673 674 TestLog.Compare(strActbase64, (strTextBase64 + strNumBase64), "Compare All Valid Base64"); 675 } 676 677 //[Variation("ReadBase64 Element with Long valid value (from concatenation), Priority=0")] TestReadBase64_6()678 public void TestReadBase64_6() 679 { 680 int base64len = 0; 681 byte[] base64 = new byte[2000]; 682 683 XmlReader DataReader = GetReader(pBase64Xml); 684 PositionOnElement(DataReader, ST_ELEM_NAME6); 685 if (!DataReader.CanReadBinaryContent) return; 686 687 base64len = DataReader.ReadElementContentAsBase64(base64, 0, base64.Length); 688 689 string strActbase64 = ""; 690 for (int i = 0; i < base64len; i = i + 2) 691 { 692 strActbase64 += System.BitConverter.ToChar(base64, i); 693 } 694 695 string strExpbase64 = ""; 696 for (int i = 0; i < 10; i++) 697 strExpbase64 += (strTextBase64 + strNumBase64); 698 699 TestLog.Compare(strActbase64, strExpbase64, "Compare All Valid Base64"); 700 } 701 702 //[Variation("ReadBase64 with count > buffer size")] ReadBase64_7()703 public void ReadBase64_7() 704 { 705 BoolToLTMResult(VerifyInvalidReadBase64(5, 0, 6, typeof(ArgumentOutOfRangeException))); 706 } 707 708 //[Variation("ReadBase64 with count < 0")] ReadBase64_8()709 public void ReadBase64_8() 710 { 711 BoolToLTMResult(VerifyInvalidReadBase64(5, 2, -1, typeof(ArgumentOutOfRangeException))); 712 } 713 714 //[Variation("ReadBase64 with index > buffer size")] ReadBase64_9()715 public void ReadBase64_9() 716 { 717 BoolToLTMResult(VerifyInvalidReadBase64(5, 5, 1, typeof(ArgumentOutOfRangeException))); 718 } 719 720 //[Variation("ReadBase64 with index < 0")] ReadBase64_10()721 public void ReadBase64_10() 722 { 723 BoolToLTMResult(VerifyInvalidReadBase64(5, -1, 1, typeof(ArgumentOutOfRangeException))); 724 } 725 726 //[Variation("ReadBase64 with index + count exceeds buffer")] ReadBase64_11()727 public void ReadBase64_11() 728 { 729 BoolToLTMResult(VerifyInvalidReadBase64(5, 0, 10, typeof(ArgumentOutOfRangeException))); 730 } 731 732 //[Variation("ReadBase64 index & count =0")] ReadBase64_12()733 public void ReadBase64_12() 734 { 735 byte[] buffer = new byte[5]; 736 int iCount = 0; 737 738 XmlReader DataReader = GetReader(pBase64Xml); 739 PositionOnElement(DataReader, ST_ELEM_NAME1); 740 if (!DataReader.CanReadBinaryContent) return; 741 iCount = DataReader.ReadElementContentAsBase64(buffer, 0, 0); 742 743 TestLog.Compare(iCount, 0, "has to be zero"); 744 } 745 746 //[Variation("ReadBase64 Element multiple into same buffer (using offset), Priority=0")] TestReadBase64_13()747 public void TestReadBase64_13() 748 { 749 int base64len = 20; 750 byte[] base64 = new byte[base64len]; 751 752 XmlReader DataReader = GetReader(pBase64Xml); 753 PositionOnElement(DataReader, ST_ELEM_NAME4); 754 if (!DataReader.CanReadBinaryContent) return; 755 string strActbase64 = ""; 756 for (int i = 0; i < base64len; i = i + 2) 757 { 758 DataReader.ReadElementContentAsBase64(base64, i, 2); 759 strActbase64 = (System.BitConverter.ToChar(base64, i)).ToString(); 760 TestLog.Compare(String.Compare(strActbase64, 0, strTextBase64, i / 2, 1), 0, "Compare All Valid Base64"); 761 } 762 } 763 764 //[Variation("ReadBase64 with buffer == null")] TestReadBase64_14()765 public void TestReadBase64_14() 766 { 767 XmlReader DataReader = GetReader(pBase64Xml); 768 769 PositionOnElement(DataReader, ST_ELEM_NAME4); 770 if (!DataReader.CanReadBinaryContent) return; 771 try 772 { 773 DataReader.ReadElementContentAsBase64(null, 0, 0); 774 } 775 catch (ArgumentNullException) 776 { 777 return; 778 } 779 780 throw new TestException(TestResult.Failed, ""); 781 } 782 783 //[Variation("ReadBase64 after failure")] TestReadBase64_15()784 public void TestReadBase64_15() 785 { 786 XmlReader DataReader = GetReader(pBase64Xml); 787 788 PositionOnElement(DataReader, "ElemErr"); 789 if (!DataReader.CanReadBinaryContent) return; 790 791 byte[] buffer = new byte[10]; 792 int nRead = 0; 793 try 794 { 795 nRead = DataReader.ReadElementContentAsBase64(buffer, 0, 1); 796 throw new TestException(TestResult.Failed, ""); 797 } 798 catch (XmlException e) 799 { 800 CheckXmlException("Xml_InvalidBase64Value", e, 0, 1); 801 } 802 } 803 804 //[Variation("Read after partial ReadBase64", Priority = 0)] TestReadBase64_16()805 public void TestReadBase64_16() 806 { 807 XmlReader DataReader = GetReader(pBase64Xml); 808 809 PositionOnElement(DataReader, "ElemNum"); 810 if (!DataReader.CanReadBinaryContent) return; 811 812 byte[] buffer = new byte[10]; 813 int nRead = DataReader.ReadElementContentAsBase64(buffer, 0, 8); 814 TestLog.Compare(nRead, 8, "0"); 815 816 DataReader.Read(); 817 TestLog.Compare(DataReader.NodeType, XmlNodeType.Text, "1vn"); 818 } 819 820 //[Variation("Current node on multiple calls")] TestReadBase64_17()821 public void TestReadBase64_17() 822 { 823 XmlReader DataReader = GetReader(pBase64Xml); 824 PositionOnElement(DataReader, "ElemNum"); 825 if (!DataReader.CanReadBinaryContent) return; 826 827 byte[] buffer = new byte[30]; 828 829 int nRead = DataReader.ReadElementContentAsBase64(buffer, 0, 2); 830 TestLog.Compare(nRead, 2, "0"); 831 832 nRead = DataReader.ReadElementContentAsBase64(buffer, 0, 23); 833 TestLog.Compare(nRead, 22, "1"); 834 835 TestLog.Compare(DataReader.NodeType, XmlNodeType.EndElement, "Nodetype not end element"); 836 TestLog.Compare(DataReader.Name, "ElemNum", "Nodetype not end element"); 837 } 838 839 //[Variation("ReadBase64 with incomplete sequence")] TestTextReadBase64_23()840 public void TestTextReadBase64_23() 841 { 842 byte[] expected = new byte[] { 0, 16, 131, 16, 81 }; 843 844 byte[] buffer = new byte[10]; 845 string strxml = "<r><ROOT>ABCDEFG</ROOT></r>"; 846 XmlReader DataReader = GetReaderStr(strxml); 847 848 PositionOnElement(DataReader, "ROOT"); 849 if (!DataReader.CanReadBinaryContent) return; 850 851 int result = 0; 852 int nRead; 853 while ((nRead = DataReader.ReadElementContentAsBase64(buffer, result, 1)) > 0) 854 result += nRead; 855 856 TestLog.Compare(result, expected.Length, "res"); 857 for (int i = 0; i < result; i++) 858 TestLog.Compare(buffer[i], expected[i], "buffer[" + i + "]"); 859 } 860 861 //[Variation("ReadBase64 when end tag doesn't exist")] TestTextReadBase64_24()862 public void TestTextReadBase64_24() 863 { 864 byte[] buffer = new byte[5000]; 865 string strxml = "<B>" + new string('c', 5000); 866 try 867 { 868 XmlReader DataReader = GetReaderStr(strxml); 869 PositionOnElement(DataReader, "B"); 870 if (!DataReader.CanReadBinaryContent) return; 871 872 DataReader.ReadElementContentAsBase64(buffer, 0, 5000); 873 TestLog.WriteLine("Accepted incomplete element"); 874 throw new TestException(TestResult.Failed, ""); 875 } 876 catch (XmlException e) 877 { 878 CheckXmlException("Xml_UnexpectedEOFInElementContent", e, 1, 5004); 879 } 880 } 881 882 //[Variation("ReadBase64 with whitespace in the mIddle")] TestTextReadBase64_26()883 public void TestTextReadBase64_26() 884 { 885 byte[] buffer = new byte[1]; 886 string strxml = "<abc> AQID B B </abc>"; 887 int nRead; 888 889 XmlReader DataReader = GetReaderStr(strxml); 890 PositionOnElement(DataReader, "abc"); 891 if (!DataReader.CanReadBinaryContent) return; 892 893 for (int i = 0; i < 4; i++) 894 { 895 nRead = DataReader.ReadElementContentAsBase64(buffer, 0, 1); 896 TestLog.Compare(nRead, 1, "res" + i); 897 TestLog.Compare(buffer[0], (byte)(i + 1), "buffer " + i); 898 } 899 900 nRead = DataReader.ReadElementContentAsBase64(buffer, 0, 1); 901 TestLog.Compare(nRead, 0, "nRead 0"); 902 } 903 904 //[Variation("ReadBase64 with = in the mIddle")] TestTextReadBase64_27()905 public void TestTextReadBase64_27() 906 { 907 byte[] buffer = new byte[1]; 908 string strxml = "<abc>AQI=ID</abc>"; 909 int nRead; 910 911 XmlReader DataReader = GetReaderStr(strxml); 912 PositionOnElement(DataReader, "abc"); 913 if (!DataReader.CanReadBinaryContent) return; 914 915 for (int i = 0; i < 2; i++) 916 { 917 nRead = DataReader.ReadElementContentAsBase64(buffer, 0, 1); 918 TestLog.Compare(nRead, 1, "res" + i); 919 TestLog.Compare(buffer[0], (byte)(i + 1), "buffer " + i); 920 } 921 922 try 923 { 924 DataReader.ReadElementContentAsBase64(buffer, 0, 1); 925 TestLog.WriteLine("ReadBase64 with = in the middle succeeded"); 926 throw new TestException(TestResult.Failed, ""); 927 } 928 catch (XmlException e) 929 { 930 CheckXmlException("Xml_InvalidBase64Value", e, 0, 1); 931 } 932 } 933 934 //[Variation("ReadBase64 runs into an Overflow", Params = new object[] { "10000" })] 935 //[Variation("ReadBase64 runs into an Overflow", Params = new object[] { "1000000" })] 936 //[Variation("ReadBase64 runs into an Overflow", Params = new object[] { "10000000" })] ReadBase64DoesNotRunIntoOverflow2()937 public void ReadBase64DoesNotRunIntoOverflow2() 938 { 939 int totalfilesize = Convert.ToInt32(Variation.Params[0].ToString()); 940 941 string ascii = new string('c', totalfilesize); 942 943 byte[] bits = Encoding.Unicode.GetBytes(ascii); 944 string base64str = Convert.ToBase64String(bits); 945 946 string fileName = "bug105376_" + Variation.Params[0].ToString() + ".xml"; 947 FilePathUtil.addStream(fileName, new MemoryStream()); 948 StreamWriter sw = new StreamWriter(FilePathUtil.getStream(fileName)); 949 sw.Write("<root><base64>"); 950 sw.Write(base64str); 951 sw.Write("</base64></root>"); 952 sw.Flush(); 953 954 XmlReader DataReader = GetReader(fileName); 955 956 int SIZE = (totalfilesize - 30); 957 int SIZE64 = SIZE * 3 / 4; 958 959 PositionOnElement(DataReader, "base64"); 960 if (!DataReader.CanReadBinaryContent) return; 961 962 byte[] base64 = new byte[SIZE64]; 963 964 int startPos = 0; 965 int readSize = 4096; 966 967 int currentSize = 0; 968 currentSize = DataReader.ReadElementContentAsBase64(base64, startPos, readSize); 969 TestLog.Compare(currentSize, readSize, "Read other than first chunk"); 970 971 readSize = SIZE64 - readSize; 972 currentSize = DataReader.ReadElementContentAsBase64(base64, startPos, readSize); 973 TestLog.Compare(currentSize, readSize, "Read other than remaining Chunk Size"); 974 975 readSize = 0; 976 currentSize = DataReader.ReadElementContentAsBase64(base64, startPos, readSize); 977 TestLog.Compare(currentSize, 0, "Read other than Zero Bytes"); 978 979 DataReader.Dispose(); 980 } 981 982 //[Variation("SubtreeReader inserted attributes don't work with ReadContentAsBase64")] SubtreeReaderInsertedAttributesWontWorkWithReadContentAsBase64()983 public void SubtreeReaderInsertedAttributesWontWorkWithReadContentAsBase64() 984 { 985 string strxml1 = "<root xmlns='"; 986 string strxml2 = "'><bar/></root>"; 987 988 string[] binValue = new string[] { "AAECAwQFBgcI==", "0102030405060708090a0B0c" }; 989 for (int i = 0; i < binValue.Length; i++) 990 { 991 string strxml = strxml1 + binValue[i] + strxml2; 992 using (XmlReader r = GetReader(new StringReader(strxml))) 993 { 994 r.Read(); 995 r.Read(); 996 using (XmlReader sr = r.ReadSubtree()) 997 { 998 if (!sr.CanReadBinaryContent) return; 999 sr.Read(); 1000 sr.MoveToFirstAttribute(); 1001 sr.MoveToFirstAttribute(); 1002 byte[] bytes = new byte[4]; 1003 while ((sr.ReadContentAsBase64(bytes, 0, bytes.Length)) > 0) { } 1004 } 1005 } 1006 } 1007 } 1008 } 1009 } 1010 } 1011 } 1012