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&lt;/root&gt;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&lt;/root&gt;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&amp;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