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.Xml;
7 using Microsoft.Test.ModuleCore;
8 using Xunit;
9 
10 namespace CoreXml.Test.XLinq
11 {
12     public partial class FunctionalTests : TestModule
13     {
14 
15         public partial class XNodeReaderTests : XLinqTestCase
16         {
17             public partial class TCReadOuterXml : BridgeHelpers
18             {
19                 // Element names to test ReadOuterXml on
20                 private static string s_EMP1 = "EMPTY1";
21                 private static string s_EMP2 = "EMPTY2";
22                 private static string s_EMP3 = "EMPTY3";
23                 private static string s_EMP4 = "EMPTY4";
24                 private static string s_ENT1 = "ENTITY1";
25                 private static string s_NEMP0 = "NONEMPTY0";
26                 private static string s_NEMP1 = "NONEMPTY1";
27                 private static string s_NEMP2 = "NONEMPTY2";
28                 private static string s_ELEM1 = "CHARS2";
29                 private static string s_ELEM2 = "SKIP3";
30                 private static string s_ELEM3 = "CONTENT";
31                 private static string s_ELEM4 = "COMPLEX";
32 
33                 // Element names after the ReadOuterXml call
34                 private static string s_NEXT1 = "COMPLEX";
35                 private static string s_NEXT2 = "ACT2";
36                 private static string s_NEXT3 = "CHARS_ELEM1";
37                 private static string s_NEXT4 = "AFTERSKIP3";
38                 private static string s_NEXT5 = "TITLE";
39                 private static string s_NEXT6 = "ENTITY2";
40                 private static string s_NEXT7 = "DUMMY";
41 
42                 // Expected strings returned by ReadOuterXml
43                 private static string s_EXP_EMP1 = "<EMPTY1 />";
44                 private static string s_EXP_EMP2 = "<EMPTY2 val=\"abc\" />";
45                 private static string s_EXP_EMP3 = "<EMPTY3></EMPTY3>";
46                 private static string s_EXP_EMP4 = "<EMPTY4 val=\"abc\"></EMPTY4>";
47                 private static string s_EXP_NEMP1 = "<NONEMPTY1>ABCDE</NONEMPTY1>";
48                 private static string s_EXP_NEMP2 = "<NONEMPTY2 val=\"abc\">1234</NONEMPTY2>";
49                 private static string s_EXP_ELEM1 = "<CHARS2>xxx<MARKUP />yyy</CHARS2>";
50                 private static string s_EXP_ELEM2 = "<SKIP3><ELEM1 /><ELEM2>xxx yyy</ELEM2><ELEM3 /></SKIP3>";
51                 private static string s_EXP_ELEM3 = "<CONTENT><e1 a1=\"a1value\" a2=\"a2value\"><e2 a1=\"a1value\" a2=\"a2value\"><e3 a1=\"a1value\" a2=\"a2value\">leave</e3></e2></e1></CONTENT>";
52                 private static string s_EXP_ELEM4 = "<COMPLEX>Text<!-- comment --><![CDATA[cdata]]></COMPLEX>";
53                 private static string s_EXP_ENT1_EXPAND_CHAR = "<ENTITY1 att1=\"xxx&lt;xxxAxxxCxxxe1fooxxx\">xxx&gt;xxxBxxxDxxxe1fooxxx</ENTITY1>";
54 
Init()55                 public override void Init()
56                 {
57                     base.Init();
58                 }
59 
Terminate()60                 public override void Terminate()
61                 {
62                     base.Terminate();
63                 }
64 
TestOuterOnText(string strElem, string strOuterXml, string strNextElemName, bool bWhitespace)65                 void TestOuterOnText(string strElem, string strOuterXml, string strNextElemName, bool bWhitespace)
66                 {
67                     XmlReader DataReader = GetReader();//GetReader(pGenericXml);
68                     PositionOnElement(DataReader, strElem);
69                     TestLog.Compare(DataReader.ReadOuterXml(), strOuterXml, "outer");
70                     TestLog.Compare(VerifyNode(DataReader, XmlNodeType.Text, String.Empty, "\n"), true, "vn2");
71                 }
72 
TestOuterOnElement(string strElem, string strOuterXml, string strNextElemName, bool bWhitespace)73                 void TestOuterOnElement(string strElem, string strOuterXml, string strNextElemName, bool bWhitespace)
74                 {
75                     XmlReader DataReader = GetReader();//GetReader(pGenericXml);
76                     PositionOnElement(DataReader, strElem);
77                     TestLog.Compare(DataReader.ReadOuterXml(), strOuterXml, "outer");
78                     TestLog.Compare(VerifyNode(DataReader, XmlNodeType.Element, strNextElemName, String.Empty), true, "vn2");
79                 }
80 
TestOuterOnAttribute(string strElem, string strName, string strValue)81                 void TestOuterOnAttribute(string strElem, string strName, string strValue)
82                 {
83                     XmlReader DataReader = GetReader();//GetReader(pGenericXml);
84                     PositionOnElement(DataReader, strElem);
85                     DataReader.MoveToAttribute(DataReader.AttributeCount / 2);
86                     string strExpected = String.Format("{0}=\"{1}\"", strName, strValue);
87                     TestLog.Compare(DataReader.ReadOuterXml(), strExpected, "outer");
88                     TestLog.Compare(VerifyNode(DataReader, XmlNodeType.Attribute, strName, strValue), true, "vn");
89                 }
90 
TestOuterOnNodeType(XmlNodeType nt)91                 void TestOuterOnNodeType(XmlNodeType nt)
92                 {
93                     XmlReader DataReader = GetReader();//GetReader(pGenericXml);
94                     PositionOnNodeType(DataReader, nt);
95                     DataReader.Read();
96 
97                     XmlNodeType expNt = DataReader.NodeType;
98                     string expName = DataReader.Name;
99                     string expValue = DataReader.Value;
100 
101                     PositionOnNodeType(DataReader, nt);
102                     TestLog.Compare(DataReader.ReadOuterXml(), String.Empty, "outer");
103                     TestLog.Compare(VerifyNode(DataReader, expNt, expName, expValue), true, "vn");
104                 }
105 
106                 //[Variation("ReadOuterXml on empty element w/o attributes", Priority = 0)]
ReadOuterXml1()107                 public void ReadOuterXml1()
108                 {
109                     TestOuterOnText(s_EMP1, s_EXP_EMP1, s_EMP2, true);
110                 }
111 
112                 //[Variation("ReadOuterXml on empty element w/ attributes", Priority = 0)]
ReadOuterXml2()113                 public void ReadOuterXml2()
114                 {
115                     TestOuterOnText(s_EMP2, s_EXP_EMP2, s_EMP3, true);
116                 }
117 
118                 //[Variation("ReadOuterXml on full empty element w/o attributes")]
ReadOuterXml3()119                 public void ReadOuterXml3()
120                 {
121                     TestOuterOnText(s_EMP3, s_EXP_EMP3, s_NEMP0, true);
122                 }
123 
124                 //[Variation("ReadOuterXml on full empty element w/ attributes")]
ReadOuterXml4()125                 public void ReadOuterXml4()
126                 {
127                     TestOuterOnText(s_EMP4, s_EXP_EMP4, s_NEXT1, true);
128                 }
129 
130                 //[Variation("ReadOuterXml on element with text content", Priority = 0)]
ReadOuterXml5()131                 public void ReadOuterXml5()
132                 {
133                     TestOuterOnText(s_NEMP1, s_EXP_NEMP1, s_NEMP2, true);
134                 }
135 
136                 //[Variation("ReadOuterXml on element with attributes", Priority = 0)]
ReadOuterXml6()137                 public void ReadOuterXml6()
138                 {
139                     TestOuterOnText(s_NEMP2, s_EXP_NEMP2, s_NEXT2, true);
140                 }
141 
142                 //[Variation("ReadOuterXml on element with text and markup content")]
ReadOuterXml7()143                 public void ReadOuterXml7()
144                 {
145                     TestOuterOnText(s_ELEM1, s_EXP_ELEM1, s_NEXT3, true);
146                 }
147 
148                 //[Variation("ReadOuterXml with multiple level of elements")]
ReadOuterXml8()149                 public void ReadOuterXml8()
150                 {
151                     TestOuterOnElement(s_ELEM2, s_EXP_ELEM2, s_NEXT4, false);
152                 }
153 
154                 //[Variation("ReadOuterXml with multiple level of elements, text and attributes", Priority = 0)]
ReadOuterXml9()155                 public void ReadOuterXml9()
156                 {
157                     string strExpected = s_EXP_ELEM3;
158                     TestOuterOnText(s_ELEM3, strExpected, s_NEXT5, true);
159                 }
160 
161                 //[Variation("ReadOuterXml on element with complex content (CDATA, PIs, Comments)", Priority = 0)]
ReadOuterXml10()162                 public void ReadOuterXml10()
163                 {
164                     TestOuterOnText(s_ELEM4, s_EXP_ELEM4, s_NEXT7, true);
165                 }
166 
167                 //[Variation("ReadOuterXml on attribute node of empty element")]
ReadOuterXml12()168                 public void ReadOuterXml12()
169                 {
170                     TestOuterOnAttribute(s_EMP2, "val", "abc");
171                 }
172 
173                 //[Variation("ReadOuterXml on attribute node of full empty element")]
ReadOuterXml13()174                 public void ReadOuterXml13()
175                 {
176                     TestOuterOnAttribute(s_EMP4, "val", "abc");
177                 }
178 
179                 //[Variation("ReadOuterXml on attribute node", Priority = 0)]
ReadOuterXml14()180                 public void ReadOuterXml14()
181                 {
182                     TestOuterOnAttribute(s_NEMP2, "val", "abc");
183                 }
184 
185                 //[Variation("ReadOuterXml on attribute with entities, EntityHandling = ExpandEntities", Priority = 0)]
ReadOuterXml15()186                 public void ReadOuterXml15()
187                 {
188                     XmlReader DataReader = GetReader();
189                     PositionOnElement(DataReader, s_ENT1);
190 
191                     DataReader.MoveToAttribute(DataReader.AttributeCount / 2);
192 
193                     string strExpected = "att1=\"xxx&lt;xxxAxxxCxxxe1fooxxx\"";
194 
195                     TestLog.Compare(DataReader.ReadOuterXml(), strExpected, "outer");
196                     TestLog.Compare(VerifyNode(DataReader, XmlNodeType.Attribute, "att1", ST_ENT1_ATT_EXPAND_ENTITIES), true, "vn");
197                 }
198 
199                 //[Variation("ReadOuterXml on ProcessingInstruction")]
ReadOuterXml17()200                 public void ReadOuterXml17()
201                 {
202                     TestOuterOnNodeType(XmlNodeType.ProcessingInstruction);
203                 }
204 
205                 //[Variation("ReadOuterXml on CDATA")]
ReadOuterXml24()206                 public void ReadOuterXml24()
207                 {
208                     TestOuterOnNodeType(XmlNodeType.CDATA);
209                 }
210 
211                 [Fact]
ReadOuterXmlOnXmlDeclarationAttributes()212                 public void ReadOuterXmlOnXmlDeclarationAttributes()
213                 {
214                     using (XmlReader DataReader = GetPGenericXmlReader())
215                     {
216                         DataReader.Read();
217                         try
218                         {
219                             DataReader.MoveToAttribute(DataReader.AttributeCount / 2);
220                             throw new TestException(TestResult.Failed, "");
221                         }
222                         catch (ArgumentOutOfRangeException) { }
223                         Assert.True(TestLog.Compare(DataReader.ReadOuterXml(), String.Empty, "outer"));
224                         Assert.True((DataReader.NodeType != XmlNodeType.Attribute) || (DataReader.Name != String.Empty) || (DataReader.Value != "UTF-8"));
225                     }
226                 }
227 
228                 //[Variation("ReadOuterXml on element with entities, EntityHandling = ExpandCharEntities")]
TRReadOuterXml27()229                 public void TRReadOuterXml27()
230                 {
231                     string strExpected = s_EXP_ENT1_EXPAND_CHAR;
232 
233                     XmlReader DataReader = GetReader();
234                     PositionOnElement(DataReader, s_ENT1);
235 
236                     TestLog.Compare(DataReader.ReadOuterXml(), strExpected, "outer");
237                     TestLog.Compare(VerifyNode(DataReader, XmlNodeType.Element, s_NEXT6, String.Empty), true, "vn");
238                 }
239 
240                 //[Variation("ReadOuterXml on attribute with entities, EntityHandling = ExpandCharEntites")]
TRReadOuterXml28()241                 public void TRReadOuterXml28()
242                 {
243                     string strExpected = "att1=\"xxx&lt;xxxAxxxCxxxe1fooxxx\"";
244                     XmlReader DataReader = GetReader();
245                     PositionOnElement(DataReader, s_ENT1);
246                     DataReader.MoveToAttribute(DataReader.AttributeCount / 2);
247                     TestLog.Compare(DataReader.ReadOuterXml(), strExpected, "outer");
248                     TestLog.Compare(VerifyNode(DataReader, XmlNodeType.Attribute, "att1", ST_ENT1_ATT_EXPAND_ENTITIES), true, "vn");
249                 }
250 
251                 //[Variation("One large element")]
TestTextReadOuterXml29()252                 public void TestTextReadOuterXml29()
253                 {
254                     String strp = "a                                                             ";
255                     strp += strp;
256                     strp += strp;
257                     strp += strp;
258                     strp += strp;
259                     strp += strp;
260                     strp += strp;
261                     strp += strp;
262 
263                     string strxml = "<Name a=\"b\">" + strp + " </Name>";
264                     XmlReader DataReader = GetReaderStr(strxml);
265 
266                     DataReader.Read();
267                     TestLog.Compare(DataReader.ReadOuterXml(), strxml, "rox");
268                 }
269 
270                 //[Variation("Read OuterXml when Namespaces=false and has an attribute xmlns")]
ReadOuterXmlWhenNamespacesEqualsToFalseAndHasAnAttributeXmlns()271                 public void ReadOuterXmlWhenNamespacesEqualsToFalseAndHasAnAttributeXmlns()
272                 {
273                     string xml = "<?xml version='1.0' encoding='utf-8' ?> <foo xmlns=\"testing\"><bar id=\"1\" /></foo>";
274                     XmlReader DataReader = GetReaderStr(xml);
275                     DataReader.MoveToContent();
276                     TestLog.Compare(DataReader.ReadOuterXml(), "<foo xmlns=\"testing\"><bar id=\"1\" /></foo>", "mismatch");
277                 }
278             }
279         }
280     }
281 }
282