Code Coverage Statistics for Source File

Newtonsoft.Json.Tests\Converters\XmlNodeConverterTest.cs

Symbol Coverage: 96.10% (222 of 231)

Branch Coverage: 82.86% (29 of 35)

Cyclomatic Complexity Avg: 1.19 Max:3

Code Lines: 582

Symbol Coverage Trend

View:


#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion

#if !SILVERLIGHT
using System;
using Newtonsoft.Json.Tests.Serialization;
using NUnit.Framework;
using Newtonsoft.Json;
using System.IO;
using System.Xml;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Utilities;
using Newtonsoft.Json.Linq;
#if !NET20
using System.Xml.Linq;
#endif

namespace Newtonsoft.Json.Tests.Converters
{
  public class XmlNodeConverterTest : TestFixtureBase
  {
    private string SerializeXmlNode(XmlNode node)
    {
      string json = JsonConvert.SerializeXmlNode(node, Formatting.Indented);
      XmlNodeReader reader = new XmlNodeReader(node);

#if !NET20
      XObject xNode;
      if (node is XmlDocument)
      {
        xNode = XDocument.Load(reader);
      }
      else if (node is XmlAttribute)
      {
        XmlAttribute attribute = (XmlAttribute) node;
        xNode = new XAttribute(XName.Get(attribute.LocalName, attribute.NamespaceURI), attribute.Value);
      }
      else
      {
        reader.MoveToContent();
        xNode = XNode.ReadFrom(reader);
      }

      string linqJson = JsonConvert.SerializeXNode(xNode, Formatting.Indented);

      Assert.AreEqual(json, linqJson);
#endif

      return json;
    }

    private XmlNode DeserializeXmlNode(string json)
    {
      return DeserializeXmlNode(json, null);
    }

    private XmlNode DeserializeXmlNode(string json, string deserializeRootElementName)
    {
      JsonTextReader reader;

      reader = new JsonTextReader(new StringReader(json));
      reader.Read();
      XmlNodeConverter converter = new XmlNodeConverter();
      if (deserializeRootElementName != null)
        converter.DeserializeRootElementName = deserializeRootElementName;

      XmlNode node = (XmlNode)converter.ReadJson(reader, typeof (XmlDocument), null, new JsonSerializer());

#if !NET20
     string xmlText = node.OuterXml;

      reader = new JsonTextReader(new StringReader(json));
      reader.Read();
      XDocument d = (XDocument) converter.ReadJson(reader, typeof (XDocument), null, new JsonSerializer());

      string linqXmlText = d.ToString(SaveOptions.DisableFormatting);
      if (d.Declaration != null)
        linqXmlText = d.Declaration + linqXmlText;

      Assert.AreEqual(xmlText, linqXmlText);
#endif

      return node;
    }

    [Test]
    public void DocumentSerializeIndented()
    {
      string xml = @"<?xml version=""1.0"" standalone=""no""?>
<?xml-stylesheet href=""classic.xsl"" type=""text/xml""?>
<span class=""vevent"">
  <a class=""url"" href=""http://www.web2con.com/"">
    <span class=""summary"">Web 2.0 Conference<![CDATA[my escaped text]]></span>
    <abbr class=""dtstart"" title=""2005-10-05"">October 5</abbr>
    <abbr class=""dtend"" title=""2005-10-08"">7</abbr>
    <span class=""location"">Argent Hotel, San Francisco, CA</span>
  </a>
</span>";
      XmlDocument doc = new XmlDocument();
      doc.LoadXml(xml);

      string jsonText = SerializeXmlNode(doc);
      string expected = @"{
  ""?xml"": {
    ""@version"": ""1.0"",
    ""@standalone"": ""no""
  },
  ""?xml-stylesheet"": ""href=\""classic.xsl\"" type=\""text/xml\"""",
  ""span"": {
    ""@class"": ""vevent"",
    ""a"": {
      ""@class"": ""url"",
      ""@href"": ""http://www.web2con.com/"",
      ""span"": [
        {
          ""@class"": ""summary"",
          ""#text"": ""Web 2.0 Conference"",
          ""#cdata-section"": ""my escaped text""
        },
        {
          ""@class"": ""location"",
          ""#text"": ""Argent Hotel, San Francisco, CA""
        }
      ],
      ""abbr"": [
        {
          ""@class"": ""dtstart"",
          ""@title"": ""2005-10-05"",
          ""#text"": ""October 5""
        },
        {
          ""@class"": ""dtend"",
          ""@title"": ""2005-10-08"",
          ""#text"": ""7""
        }
      ]
    }
  }
}";

      Assert.AreEqual(expected, jsonText);

      Console.WriteLine("DocumentSerializeIndented");
      Console.WriteLine(jsonText);
      Console.WriteLine();
    }

    [Test]
    public void SerializeNodeTypes()
    {
      XmlDocument doc = new XmlDocument();
      string jsonText;

      Console.WriteLine("SerializeNodeTypes");

      string xml = @"<?xml version=""1.0"" encoding=""utf-8"" ?>
<xs:schema xs:id=""SomeID"" 
	xmlns="""" 
	xmlns:xs=""http://www.w3.org/2001/XMLSchema"" 
	xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
	<xs:element name=""MyDataSet"" msdata:IsDataSet=""true"">
	</xs:element>
</xs:schema>";

      XmlDocument document = new XmlDocument();
      document.LoadXml(xml);

      // XmlAttribute
      XmlAttribute attribute = document.DocumentElement.ChildNodes[0].Attributes["IsDataSet", "urn:schemas-microsoft-com:xml-msdata"];
      attribute.Value = "true";

      jsonText = JsonConvert.SerializeXmlNode(attribute);

      Console.WriteLine(jsonText);
      Assert.AreEqual(@"{""@msdata:IsDataSet"":""true""}", jsonText);

#if !NET20
      XDocument d = XDocument.Parse(xml);
      XAttribute a = d.Root.Element("{http://www.w3.org/2001/XMLSchema}element").Attribute("{urn:schemas-microsoft-com:xml-msdata}IsDataSet");

      jsonText = JsonConvert.SerializeXNode(a);

      Assert.AreEqual(@"{""@msdata:IsDataSet"":""true""}", jsonText);
#endif

      // XmlProcessingInstruction
      XmlProcessingInstruction instruction = doc.CreateProcessingInstruction("xml-stylesheet", @"href=""classic.xsl"" type=""text/xml""");

      jsonText = JsonConvert.SerializeXmlNode(instruction);

      Console.WriteLine(jsonText);
      Assert.AreEqual(@"{""?xml-stylesheet"":""href=\""classic.xsl\"" type=\""text/xml\""""}", jsonText);


      // XmlProcessingInstruction
      XmlCDataSection cDataSection = doc.CreateCDataSection("<Kiwi>true</Kiwi>");

      jsonText = JsonConvert.SerializeXmlNode(cDataSection);

      Console.WriteLine(jsonText);
      Assert.AreEqual(@"{""#cdata-section"":""<Kiwi>true</Kiwi>""}", jsonText);


      // XmlElement
      XmlElement element = doc.CreateElement("xs", "Choice", "http://www.w3.org/2001/XMLSchema");
      element.SetAttributeNode(doc.CreateAttribute("msdata", "IsDataSet", "urn:schemas-microsoft-com:xml-msdata"));

      XmlAttribute aa = doc.CreateAttribute(@"xmlns", "xs", "http://www.w3.org/2000/xmlns/");
      aa.Value = "http://www.w3.org/2001/XMLSchema";
      element.SetAttributeNode(aa);

      aa = doc.CreateAttribute(@"xmlns", "msdata", "http://www.w3.org/2000/xmlns/");
      aa.Value = "urn:schemas-microsoft-com:xml-msdata";
      element.SetAttributeNode(aa);

      element.AppendChild(instruction);
      element.AppendChild(cDataSection);

      doc.AppendChild(element);

      jsonText = JsonConvert.SerializeXmlNode(element, Formatting.Indented);

      Assert.AreEqual(@"{
  ""xs:Choice"": {
    ""@msdata:IsDataSet"": """",
    ""@xmlns:xs"": ""http://www.w3.org/2001/XMLSchema"",
    ""@xmlns:msdata"": ""urn:schemas-microsoft-com:xml-msdata"",
    ""?xml-stylesheet"": ""href=\""classic.xsl\"" type=\""text/xml\"""",
    ""#cdata-section"": ""<Kiwi>true</Kiwi>""
  }
}", jsonText);
    }

    [Test]
    public void DocumentFragmentSerialize()
    {
      XmlDocument doc = new XmlDocument();

      XmlDocumentFragment fragement = doc.CreateDocumentFragment();

      fragement.InnerXml = "<Item>widget</Item><Item>widget</Item>";

      string jsonText = JsonConvert.SerializeXmlNode(fragement);

      string expected = @"{""Item"":[""widget"",""widget""]}";

      Assert.AreEqual(expected, jsonText);

      Console.WriteLine("DocumentFragmentSerialize");
      Console.WriteLine(jsonText);
      Console.WriteLine();
    }

    [Test]
    public void NamespaceSerializeDeserialize()
    {
      string xml = @"<?xml version=""1.0"" encoding=""utf-8"" ?>
<xs:schema xs:id=""SomeID"" 
	xmlns="""" 
	xmlns:xs=""http://www.w3.org/2001/XMLSchema"" 
	xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
	<xs:element name=""MyDataSet"" msdata:IsDataSet=""true"">
		<xs:complexType>
			<xs:choice maxOccurs=""unbounded"">
				<xs:element name=""customers"" >
					<xs:complexType >
						<xs:sequence>
							<xs:element name=""CustomerID"" type=""xs:integer"" 
										 minOccurs=""0"" />
							<xs:element name=""CompanyName"" type=""xs:string"" 
										 minOccurs=""0"" />
							<xs:element name=""Phone"" type=""xs:string"" />
						</xs:sequence>
					</xs:complexType>
				</xs:element>
			</xs:choice>
		</xs:complexType>
	</xs:element>
</xs:schema>";

      XmlDocument doc = new XmlDocument();
      doc.LoadXml(xml);

      string jsonText = SerializeXmlNode(doc);

      string expected = @"{
  ""?xml"": {
    ""@version"": ""1.0"",
    ""@encoding"": ""utf-8""
  },
  ""xs:schema"": {
    ""@xs:id"": ""SomeID"",
    ""@xmlns"": """",
    ""@xmlns:xs"": ""http://www.w3.org/2001/XMLSchema"",
    ""@xmlns:msdata"": ""urn:schemas-microsoft-com:xml-msdata"",
    ""xs:element"": {
      ""@name"": ""MyDataSet"",
      ""@msdata:IsDataSet"": ""true"",
      ""xs:complexType"": {
        ""xs:choice"": {
          ""@maxOccurs"": ""unbounded"",
          ""xs:element"": {
            ""@name"": ""customers"",
            ""xs:complexType"": {
              ""xs:sequence"": {
                ""xs:element"": [
                  {
                    ""@name"": ""CustomerID"",
                    ""@type"": ""xs:integer"",
                    ""@minOccurs"": ""0""
                  },
                  {
                    ""@name"": ""CompanyName"",
                    ""@type"": ""xs:string"",
                    ""@minOccurs"": ""0""
                  },
                  {
                    ""@name"": ""Phone"",
                    ""@type"": ""xs:string""
                  }
                ]
              }
            }
          }
        }
      }
    }
  }
}";

      Assert.AreEqual(expected, jsonText);

      XmlDocument deserializedDoc = (XmlDocument)DeserializeXmlNode(jsonText);

      Assert.AreEqual(doc.InnerXml, deserializedDoc.InnerXml);

      Console.WriteLine("NamespaceSerializeDeserialize");
      Console.WriteLine(jsonText);
      Console.WriteLine(deserializedDoc.InnerXml);
      Console.WriteLine();
    }

    [Test]
    public void DocumentDeserialize()
    {
      string jsonText = @"{
  ""?xml"": {
    ""@version"": ""1.0"",
    ""@standalone"": ""no""
  },
  ""span"": {
    ""@class"": ""vevent"",
    ""a"": {
      ""@class"": ""url"",
      ""@href"": ""http://www.web2con.com/"",
      ""span"": {
        ""@class"": ""summary"",
        ""#text"": ""Web 2.0 Conference"",
        ""#cdata-section"": ""my escaped text""
      }
    }
  }
}";

      XmlDocument doc = (XmlDocument)DeserializeXmlNode(jsonText);

      string expected = @"<?xml version=""1.0"" standalone=""no""?>
<span class=""vevent"">
  <a class=""url"" href=""http://www.web2con.com/"">
    <span class=""summary"">Web 2.0 Conference<![CDATA[my escaped text]]></span>
  </a>
</span>";

      string formattedXml = GetIndentedInnerXml(doc);

      Console.WriteLine("DocumentDeserialize");
      Console.WriteLine(formattedXml);
      Console.WriteLine();

      Assert.AreEqual(expected, formattedXml);
    }

    private string GetIndentedInnerXml(XmlNode node)
    {
      XmlWriterSettings settings = new XmlWriterSettings();
      settings.Indent = true;

      StringWriter sw = new StringWriter();

      using (XmlWriter writer = XmlWriter.Create(sw, settings))
      {
        node.WriteTo(writer);
      }

      return sw.ToString();
    }

    [Test]
    public void SingleTextNode()
    {
      string xml = @"<?xml version=""1.0"" standalone=""no""?>
			<root>
			  <person id=""1"">
				<name>Alan</name>
				<url>http://www.google.com</url>
			  </person>
			  <person id=""2"">
				<name>Louis</name>
				<url>http://www.yahoo.com</url>
			  </person>
			</root>";

      XmlDocument doc = new XmlDocument();
      doc.LoadXml(xml);

      string jsonText = SerializeXmlNode(doc);

      XmlDocument newDoc = (XmlDocument)DeserializeXmlNode(jsonText);

      Assert.AreEqual(doc.InnerXml, newDoc.InnerXml);
    }

    [Test]
    public void EmptyNode()
    {
      string xml = @"<?xml version=""1.0"" standalone=""no""?>
			<root>
			  <person id=""1"">
				<name>Alan</name>
				<url />
			  </person>
			  <person id=""2"">
				<name>Louis</name>
				<url>http://www.yahoo.com</url>
			  </person>
			</root>";

      XmlDocument doc = new XmlDocument();
      doc.LoadXml(xml);

      string jsonText = SerializeXmlNode(doc);

      Console.WriteLine(jsonText);

      XmlDocument newDoc = (XmlDocument)DeserializeXmlNode(jsonText);

      Assert.AreEqual(doc.InnerXml, newDoc.InnerXml);
    }

    [Test]
    public void OtherElementDataTypes()
    {
      string jsonText = @"{""?xml"":{""@version"":""1.0"",""@standalone"":""no""},""root"":{""person"":[{""@id"":""1"",""Float"":2.5,""Integer"":99},{""@id"":""2"",""Boolean"":true,""date"":""\/Date(954374400000)\/""}]}}";

      XmlDocument newDoc = (XmlDocument)DeserializeXmlNode(jsonText);

      string expected = @"<?xml version=""1.0"" standalone=""no""?><root><person id=""1""><Float>2.5</Float><Integer>99</Integer></person><person id=""2""><Boolean>true</Boolean><date>2000-03-30T00:00:00Z</date></person></root>";

      Assert.AreEqual(expected, newDoc.InnerXml);
    }

    [Test]
    [ExpectedException(typeof(JsonSerializationException), ExpectedMessage = "XmlNodeConverter can only convert JSON that begins with an object.")]
    public void NoRootObject()
    {
      XmlDocument newDoc = (XmlDocument)JsonConvert.DeserializeXmlNode(@"[1]");
    }

    [Test]
    [ExpectedException(typeof(JsonSerializationException), ExpectedMessage = "JSON root object has multiple properties. The root object must have a single property in order to create a valid XML document. Consider specifing a DeserializeRootElementName.")]
    public void RootObjectMultipleProperties()
    {
      XmlDocument newDoc = (XmlDocument)JsonConvert.DeserializeXmlNode(@"{Prop1:1,Prop2:2}");
    }

    [Test]
    public void JavaScriptConstructor()
    {
      string jsonText = @"{root:{r:new Date(34343, 55)}}";

      XmlDocument newDoc = (XmlDocument)DeserializeXmlNode(jsonText);

      string expected = @"<root><r><Date>34343</Date><Date>55</Date></r></root>";

      Assert.AreEqual(expected, newDoc.InnerXml);

      string json = SerializeXmlNode(newDoc);
      expected = @"{
  ""root"": {
    ""r"": {
      ""Date"": [
        ""34343"",
        ""55""
      ]
    }
  }
}";

      Assert.AreEqual(expected, json);
    }

    [Test]
    public void ForceJsonArray()
    {
      string arrayXml = @"<root xmlns:json=""http://james.newtonking.com/projects/json"">
			  <person id=""1"">
				  <name>Alan</name>
				  <url>http://www.google.com</url>
				  <role json:Array=""true"">Admin</role>
			  </person>
			</root>";

      XmlDocument arrayDoc = new XmlDocument();
      arrayDoc.LoadXml(arrayXml);

      string arrayJsonText = SerializeXmlNode(arrayDoc);
      string expected = @"{
  ""root"": {
    ""person"": {
      ""@id"": ""1"",
      ""name"": ""Alan"",
      ""url"": ""http://www.google.com"",
      ""role"": [
        ""Admin""
      ]
    }
  }
}";
      Assert.AreEqual(expected, arrayJsonText);

      arrayXml = @"<root xmlns:json=""http://james.newtonking.com/projects/json"">
			  <person id=""1"">
				  <name>Alan</name>
				  <url>http://www.google.com</url>
				  <role json:Array=""true"">Admin1</role>
				  <role json:Array=""true"">Admin2</role>
			  </person>
			</root>";

      arrayDoc = new XmlDocument();
      arrayDoc.LoadXml(arrayXml);

      arrayJsonText = SerializeXmlNode(arrayDoc);
      expected = @"{
  ""root"": {
    ""person"": {
      ""@id"": ""1"",
      ""name"": ""Alan"",
      ""url"": ""http://www.google.com"",
      ""role"": [
        ""Admin1"",
        ""Admin2""
      ]
    }
  }
}";
      Assert.AreEqual(expected, arrayJsonText);

      arrayXml = @"<root xmlns:json=""http://james.newtonking.com/projects/json"">
			  <person id=""1"">
				  <name>Alan</name>
				  <url>http://www.google.com</url>
				  <role json:Array=""false"">Admin1</role>
			  </person>
			</root>";

      arrayDoc = new XmlDocument();
      arrayDoc.LoadXml(arrayXml);

      arrayJsonText = SerializeXmlNode(arrayDoc);
      expected = @"{
  ""root"": {
    ""person"": {
      ""@id"": ""1"",
      ""name"": ""Alan"",
      ""url"": ""http://www.google.com"",
      ""role"": ""Admin1""
    }
  }
}";
      Assert.AreEqual(expected, arrayJsonText);
    }

    [Test]
    [ExpectedException(typeof(JsonSerializationException), ExpectedMessage = "JSON root object has multiple properties. The root object must have a single property in order to create a valid XML document. Consider specifing a DeserializeRootElementName.")]
    public void MultipleRootPropertiesXmlDocument()
    {
      string json = @"{""count"": 773840,""photos"": null}";

      JsonConvert.DeserializeXmlNode(json);
    }

#if !NET20
    [Test]
    [ExpectedException(typeof(JsonSerializationException), ExpectedMessage = "JSON root object has multiple properties. The root object must have a single property in order to create a valid XML document. Consider specifing a DeserializeRootElementName.")]
    public void MultipleRootPropertiesXDocument()
    {
      string json = @"{""count"": 773840,""photos"": null}";

      JsonConvert.DeserializeXNode(json);
    }
#endif

    [Test]
    public void MultipleRootPropertiesAddRootElement()
    {
      string json = @"{""count"": 773840,""photos"": 773840}";

      XmlDocument newDoc = JsonConvert.DeserializeXmlNode(json, "myRoot");

      Assert.AreEqual(@"<myRoot><count>773840</count><photos>773840</photos></myRoot>", newDoc.InnerXml);

#if !NET20
     XDocument newXDoc = JsonConvert.DeserializeXNode(json, "myRoot");

      Assert.AreEqual(@"<myRoot><count>773840</count><photos>773840</photos></myRoot>", newXDoc.ToString(SaveOptions.DisableFormatting));
#endif
    }

    [Test]
    public void NestedArrays()
    {
      string json = @"{
  ""available_sizes"": [
    [
      ""assets/images/resized/0001/1070/11070v1-max-150x150.jpg"",
      ""assets/images/resized/0001/1070/11070v1-max-150x150.jpg""
    ],
    [
      ""assets/images/resized/0001/1070/11070v1-max-250x250.jpg"",
      ""assets/images/resized/0001/1070/11070v1-max-250x250.jpg""
    ]
  ]
}";

      XmlDocument newDoc = JsonConvert.DeserializeXmlNode(json, "myRoot");

      Assert.AreEqual(@"<myRoot><available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-150x150.jpg</available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-150x150.jpg</available_sizes></available_sizes><available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-250x250.jpg</available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-250x250.jpg</available_sizes></available_sizes></myRoot>", newDoc.InnerXml);

#if !NET20
      XDocument newXDoc = JsonConvert.DeserializeXNode(json, "myRoot");

      Assert.AreEqual(@"<myRoot><available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-150x150.jpg</available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-150x150.jpg</available_sizes></available_sizes><available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-250x250.jpg</available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-250x250.jpg</available_sizes></available_sizes></myRoot>", newXDoc.ToString(SaveOptions.DisableFormatting));
#endif
    }

    [Test]
    public void MultipleNestedArraysToXml()
    {
      string json = @"{
  ""available_sizes"": [
    [
      [113, 150],
      ""assets/images/resized/0001/1070/11070v1-max-150x150.jpg""
    ],
    [
      [189, 250],
      ""assets/images/resized/0001/1070/11070v1-max-250x250.jpg""
    ],
    [
      [341, 450],
      ""assets/images/resized/0001/1070/11070v1-max-450x450.jpg""
    ]
  ]
}";

      XmlDocument newDoc = JsonConvert.DeserializeXmlNode(json, "myRoot");

      Assert.AreEqual(@"<myRoot><available_sizes><available_sizes><available_sizes>113</available_sizes><available_sizes>150</available_sizes></available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-150x150.jpg</available_sizes></available_sizes><available_sizes><available_sizes><available_sizes>189</available_sizes><available_sizes>250</available_sizes></available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-250x250.jpg</available_sizes></available_sizes><available_sizes><available_sizes><available_sizes>341</available_sizes><available_sizes>450</available_sizes></available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-450x450.jpg</available_sizes></available_sizes></myRoot>", newDoc.InnerXml);

#if !NET20
      XDocument newXDoc = JsonConvert.DeserializeXNode(json, "myRoot");

      Assert.AreEqual(@"<myRoot><available_sizes><available_sizes><available_sizes>113</available_sizes><available_sizes>150</available_sizes></available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-150x150.jpg</available_sizes></available_sizes><available_sizes><available_sizes><available_sizes>189</available_sizes><available_sizes>250</available_sizes></available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-250x250.jpg</available_sizes></available_sizes><available_sizes><available_sizes><available_sizes>341</available_sizes><available_sizes>450</available_sizes></available_sizes><available_sizes>assets/images/resized/0001/1070/11070v1-max-450x450.jpg</available_sizes></available_sizes></myRoot>", newXDoc.ToString(SaveOptions.DisableFormatting));
#endif
    }

    [Test]
    public void Encoding()
    {
      XmlDocument doc = new XmlDocument();

      doc.LoadXml(@"<name>O""Connor</name>"); // i use "" so it will be easier to see the  problem

      string json = SerializeXmlNode(doc);
      Assert.AreEqual(@"{
  ""name"": ""O\""Connor""
}", json);
    }

    [Test]
    public void SerializeComment()
    {
      string xml = @"<span class=""vevent"">
  <a class=""url"" href=""http://www.web2con.com/"">Text</a><!-- Hi! -->
</span>";
      XmlDocument doc = new XmlDocument();
      doc.LoadXml(xml);

      string jsonText = SerializeXmlNode(doc);

      string expected = @"{
  ""span"": {
    ""@class"": ""vevent"",
    ""a"": {
      ""@class"": ""url"",
      ""@href"": ""http://www.web2con.com/"",
      ""#text"": ""Text""
    }/* Hi! */
  }
}";

      Assert.AreEqual(expected, jsonText);

      XmlDocument newDoc = (XmlDocument)DeserializeXmlNode(jsonText);
      Assert.AreEqual(@"<span class=""vevent""><a class=""url"" href=""http://www.web2con.com/"">Text</a><!-- Hi! --></span>", newDoc.InnerXml);
    }

    [Test]
    public void SerializeExample()
    {
      string xml = @"<?xml version=""1.0"" standalone=""no""?>
			<root>
			  <person id=""1"">
				<name>Alan</name>
				<url>http://www.google.com</url>
			  </person>
			  <person id=""2"">
				<name>Louis</name>
				<url>http://www.yahoo.com</url>
			  </person>
			</root>";

      XmlDocument doc = new XmlDocument();
      doc.LoadXml(xml);

      string jsonText = SerializeXmlNode(doc);
      // {
      //   "?xml": {
      //     "@version": "1.0",
      //     "@standalone": "no"
      //   },
      //   "root": {
      //     "person": [
      //       {
      //         "@id": "1",
      //         "name": "Alan",
      //         "url": "http://www.google.com"
      //       },
      //       {
      //         "@id": "2",
      //         "name": "Louis",
      //         "url": "http://www.yahoo.com"
      //       }
      //     ]
      //   }
      // }

      // format
      jsonText = JObject.Parse(jsonText).ToString();

      Assert.AreEqual(@"{
  ""?xml"": {
    ""@version"": ""1.0"",
    ""@standalone"": ""no""
  },
  ""root"": {
    ""person"": [
      {
        ""@id"": ""1"",
        ""name"": ""Alan"",
        ""url"": ""http://www.google.com""
      },
      {
        ""@id"": ""2"",
        ""name"": ""Louis"",
        ""url"": ""http://www.yahoo.com""
      }
    ]
  }
}", jsonText);

      XmlDocument newDoc = (XmlDocument)DeserializeXmlNode(jsonText);

      Assert.AreEqual(doc.InnerXml, newDoc.InnerXml);
    }

    [Test]
    public void DeserializeExample()
    {
      string json = @"{
        ""?xml"": {
          ""@version"": ""1.0"",
          ""@standalone"": ""no""
        },
        ""root"": {
          ""person"": [
            {
              ""@id"": ""1"",
              ""name"": ""Alan"",
              ""url"": ""http://www.google.com""
            },
            {
              ""@id"": ""2"",
              ""name"": ""Louis"",
              ""url"": ""http://www.yahoo.com""
            }
          ]
        }
      }";

      XmlDocument doc = (XmlDocument)DeserializeXmlNode(json);
      // <?xml version="1.0" standalone="no"?>
      // <root>
      //   <person id="1">
      //   <name>Alan</name>
      //   <url>http://www.google.com</url>
      //   </person>
      //   <person id="2">
      //   <name>Louis</name>
      //   <url>http://www.yahoo.com</url>
      //   </person>
      // </root>

      Assert.AreEqual(@"<?xml version=""1.0"" standalone=""no""?>
<root>
<person id=""1"">
<name>Alan</name>
<url>http://www.google.com</url>
</person>
<person id=""2"">
<name>Louis</name>
<url>http://www.yahoo.com</url>
</person>
</root>".Replace(Environment.NewLine, string.Empty), doc.InnerXml);
    }

    [Test]
    public void SerializeDeserializeSpecialProperties()
    {
      PreserveReferencesHandlingTests.CircularDictionary circularDictionary = new PreserveReferencesHandlingTests.CircularDictionary();
      circularDictionary.Add("other", new PreserveReferencesHandlingTests.CircularDictionary { { "blah", null } });
      circularDictionary.Add("self", circularDictionary);

      string json = JsonConvert.SerializeObject(circularDictionary, Formatting.Indented,
        new JsonSerializerSettings { PreserveReferencesHandling = PreserveReferencesHandling.All });

      Assert.AreEqual(@"{
  ""$id"": ""1"",
  ""other"": {
    ""$id"": ""2"",
    ""blah"": null
  },
  ""self"": {
    ""$ref"": ""1""
  }
}", json);

      XmlNode node = DeserializeXmlNode(json, "root");
      string xml = GetIndentedInnerXml(node);
      string expected = @"<?xml version=""1.0"" encoding=""utf-16""?>
<root xmlns:json=""http://james.newtonking.com/projects/json"" json:id=""1"">
  <other json:id=""2"">
    <blah />
  </other>
  <self json:ref=""1"" />
</root>";

      Assert.AreEqual(expected, xml);

      string xmlJson = SerializeXmlNode(node);
      string expectedXmlJson = @"{
  ""root"": {
    ""$id"": ""1"",
    ""other"": {
      ""$id"": ""2"",
      ""blah"": null
    },
    ""self"": {
      ""$ref"": ""1""
    }
  }
}";

      Assert.AreEqual(expectedXmlJson, xmlJson);
    }
  }
}
#endif

L	V	Source
1		#region License
2		// Copyright (c) 2007 James Newton-King
3		//
4		// Permission is hereby granted, free of charge, to any person
5		// obtaining a copy of this software and associated documentation
6		// files (the "Software"), to deal in the Software without
7		// restriction, including without limitation the rights to use,
8		// copy, modify, merge, publish, distribute, sublicense, and/or sell
9		// copies of the Software, and to permit persons to whom the
10		// Software is furnished to do so, subject to the following
11		// conditions:
12		//
13		// The above copyright notice and this permission notice shall be
14		// included in all copies or substantial portions of the Software.
15		//
16		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17		// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
18		// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19		// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20		// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21		// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22		// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23		// OTHER DEALINGS IN THE SOFTWARE.
24		#endregion
25
26		#if !SILVERLIGHT
27		using System;
28		using Newtonsoft.Json.Tests.Serialization;
29		using NUnit.Framework;
30		using Newtonsoft.Json;
31		using System.IO;
32		using System.Xml;
33		using Newtonsoft.Json.Converters;
34		using Newtonsoft.Json.Utilities;
35		using Newtonsoft.Json.Linq;
36		#if !NET20
37		using System.Xml.Linq;
38		#endif
39
40		namespace Newtonsoft.Json.Tests.Converters
41		{
42		public class XmlNodeConverterTest : TestFixtureBase
43		{
44		private string SerializeXmlNode(XmlNode node)
45		{
46	12	string json = JsonConvert.SerializeXmlNode(node, Formatting.Indented);
47	12	XmlNodeReader reader = new XmlNodeReader(node);
48
49		#if !NET20
50		XObject xNode;
51	12	if (node is XmlDocument)
52		{
53	12	xNode = XDocument.Load(reader);
54		}
55	0	else if (node is XmlAttribute)
56		{
57	0	XmlAttribute attribute = (XmlAttribute) node;
58	0	xNode = new XAttribute(XName.Get(attribute.LocalName, attribute.NamespaceURI), attribute.Value);
59		}
60		else
61		{
62	0	reader.MoveToContent();
63	0	xNode = XNode.ReadFrom(reader);
64		}
65
66	12	string linqJson = JsonConvert.SerializeXNode(xNode, Formatting.Indented);
67
68	12	Assert.AreEqual(json, linqJson);
69		#endif
70
71	12	return json;
72	12	}
73
74		private XmlNode DeserializeXmlNode(string json)
75		{
76	9	return DeserializeXmlNode(json, null);
77	9	}
78
79		private XmlNode DeserializeXmlNode(string json, string deserializeRootElementName)
80		{
81		JsonTextReader reader;
82
83	10	reader = new JsonTextReader(new StringReader(json));
84	10	reader.Read();
85	10	XmlNodeConverter converter = new XmlNodeConverter();
86	10	if (deserializeRootElementName != null)
87	1	converter.DeserializeRootElementName = deserializeRootElementName;
88
89	10	XmlNode node = (XmlNode)converter.ReadJson(reader, typeof (XmlDocument), null, new JsonSerializer());
90
91		#if !NET20
92	10	string xmlText = node.OuterXml;
93
94	10	reader = new JsonTextReader(new StringReader(json));
95	10	reader.Read();
96	10	XDocument d = (XDocument) converter.ReadJson(reader, typeof (XDocument), null, new JsonSerializer());
97
98	10	string linqXmlText = d.ToString(SaveOptions.DisableFormatting);
99	10	if (d.Declaration != null)
100	7	linqXmlText = d.Declaration + linqXmlText;
101
102	10	Assert.AreEqual(xmlText, linqXmlText);
103		#endif
104
105	10	return node;
106	10	}
107
108		[Test]
109		public void DocumentSerializeIndented()
110		{
111	1	string xml = @"<?xml version=""1.0"" standalone=""no""?>
112	1	<?xml-stylesheet href=""classic.xsl"" type=""text/xml""?>
113	1	<span class=""vevent"">
114	1	<a class=""url"" href=""http://www.web2con.com/"">
115	1	<span class=""summary"">Web 2.0 Conference<![CDATA[my escaped text]]></span>
116	1	<abbr class=""dtstart"" title=""2005-10-05"">October 5</abbr>
117	1	<abbr class=""dtend"" title=""2005-10-08"">7</abbr>
118	1	<span class=""location"">Argent Hotel, San Francisco, CA</span>
119	1	</a>
120	1	</span>";
121	1	XmlDocument doc = new XmlDocument();
122	1	doc.LoadXml(xml);
123
124	1	string jsonText = SerializeXmlNode(doc);
125	1	string expected = @"{
126	1	""?xml"": {
127	1	""@version"": ""1.0"",
128	1	""@standalone"": ""no""
129	1	},
130	1	""?xml-stylesheet"": ""href=\""classic.xsl\"" type=\""text/xml\"""",
131	1	""span"": {
132	1	""@class"": ""vevent"",
133	1	""a"": {
134	1	""@class"": ""url"",
135	1	""@href"": ""http://www.web2con.com/"",
136	1	""span"": [
137	1	{
138	1	""@class"": ""summary"",
139	1	""#text"": ""Web 2.0 Conference"",
140	1	""#cdata-section"": ""my escaped text""
141	1	},
142	1	{
143	1	""@class"": ""location"",
144	1	""#text"": ""Argent Hotel, San Francisco, CA""
145	1	}
146	1	],
147	1	""abbr"": [
148	1	{
149	1	""@class"": ""dtstart"",
150	1	""@title"": ""2005-10-05"",
151	1	""#text"": ""October 5""
152	1	},
153	1	{
154	1	""@class"": ""dtend"",
155	1	""@title"": ""2005-10-08"",
156	1	""#text"": ""7""
157	1	}
158	1	]
159	1	}
160	1	}
161	1	}";
162
163	1	Assert.AreEqual(expected, jsonText);
164
165	1	Console.WriteLine("DocumentSerializeIndented");
166	1	Console.WriteLine(jsonText);
167	1	Console.WriteLine();
168	1	}
169
170		[Test]
171		public void SerializeNodeTypes()
172		{
173	1	XmlDocument doc = new XmlDocument();
174		string jsonText;
175
176	1	Console.WriteLine("SerializeNodeTypes");
177
178	1	string xml = @"<?xml version=""1.0"" encoding=""utf-8"" ?>
179	1	<xs:schema xs:id=""SomeID""
180	1	xmlns=""""
181	1	xmlns:xs=""http://www.w3.org/2001/XMLSchema""
182	1	xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
183	1	<xs:element name=""MyDataSet"" msdata:IsDataSet=""true"">
184	1	</xs:element>
185	1	</xs:schema>";
186
187	1	XmlDocument document = new XmlDocument();
188	1	document.LoadXml(xml);
189
190		// XmlAttribute
191	1	XmlAttribute attribute = document.DocumentElement.ChildNodes[0].Attributes["IsDataSet", "urn:schemas-microsoft-com:xml-msdata"];
192	1	attribute.Value = "true";
193
194	1	jsonText = JsonConvert.SerializeXmlNode(attribute);
195
196	1	Console.WriteLine(jsonText);
197	1	Assert.AreEqual(@"{""@msdata:IsDataSet"":""true""}", jsonText);
198
199		#if !NET20
200	1	XDocument d = XDocument.Parse(xml);
201	1	XAttribute a = d.Root.Element("{http://www.w3.org/2001/XMLSchema}element").Attribute("{urn:schemas-microsoft-com:xml-msdata}IsDataSet");
202
203	1	jsonText = JsonConvert.SerializeXNode(a);
204
205	1	Assert.AreEqual(@"{""@msdata:IsDataSet"":""true""}", jsonText);
206		#endif
207
208		// XmlProcessingInstruction
209	1	XmlProcessingInstruction instruction = doc.CreateProcessingInstruction("xml-stylesheet", @"href=""classic.xsl"" type=""text/xml""");
210
211	1	jsonText = JsonConvert.SerializeXmlNode(instruction);
212
213	1	Console.WriteLine(jsonText);
214	1	Assert.AreEqual(@"{""?xml-stylesheet"":""href=\""classic.xsl\"" type=\""text/xml\""""}", jsonText);
215
216
217		// XmlProcessingInstruction
218	1	XmlCDataSection cDataSection = doc.CreateCDataSection("<Kiwi>true</Kiwi>");
219
220	1	jsonText = JsonConvert.SerializeXmlNode(cDataSection);
221
222	1	Console.WriteLine(jsonText);
223	1	Assert.AreEqual(@"{""#cdata-section"":""<Kiwi>true</Kiwi>""}", jsonText);
224
225
226		// XmlElement
227	1	XmlElement element = doc.CreateElement("xs", "Choice", "http://www.w3.org/2001/XMLSchema");
228	1	element.SetAttributeNode(doc.CreateAttribute("msdata", "IsDataSet", "urn:schemas-microsoft-com:xml-msdata"));
229
230	1	XmlAttribute aa = doc.CreateAttribute(@"xmlns", "xs", "http://www.w3.org/2000/xmlns/");
231	1	aa.Value = "http://www.w3.org/2001/XMLSchema";
232	1	element.SetAttributeNode(aa);
233
234	1	aa = doc.CreateAttribute(@"xmlns", "msdata", "http://www.w3.org/2000/xmlns/");
235	1	aa.Value = "urn:schemas-microsoft-com:xml-msdata";
236	1	element.SetAttributeNode(aa);
237
238	1	element.AppendChild(instruction);
239	1	element.AppendChild(cDataSection);
240
241	1	doc.AppendChild(element);
242
243	1	jsonText = JsonConvert.SerializeXmlNode(element, Formatting.Indented);
244
245	1	Assert.AreEqual(@"{
246	1	""xs:Choice"": {
247	1	""@msdata:IsDataSet"": """",
248	1	""@xmlns:xs"": ""http://www.w3.org/2001/XMLSchema"",
249	1	""@xmlns:msdata"": ""urn:schemas-microsoft-com:xml-msdata"",
250	1	""?xml-stylesheet"": ""href=\""classic.xsl\"" type=\""text/xml\"""",
251	1	""#cdata-section"": ""<Kiwi>true</Kiwi>""
252	1	}
253	1	}", jsonText);
254	1	}
255
256		[Test]
257		public void DocumentFragmentSerialize()
258		{
259	1	XmlDocument doc = new XmlDocument();
260
261	1	XmlDocumentFragment fragement = doc.CreateDocumentFragment();
262
263	1	fragement.InnerXml = "<Item>widget</Item><Item>widget</Item>";
264
265	1	string jsonText = JsonConvert.SerializeXmlNode(fragement);
266
267	1	string expected = @"{""Item"":[""widget"",""widget""]}";
268
269	1	Assert.AreEqual(expected, jsonText);
270
271	1	Console.WriteLine("DocumentFragmentSerialize");
272	1	Console.WriteLine(jsonText);
273	1	Console.WriteLine();
274	1	}
275
276		[Test]
277		public void NamespaceSerializeDeserialize()
278		{
279	1	string xml = @"<?xml version=""1.0"" encoding=""utf-8"" ?>
280	1	<xs:schema xs:id=""SomeID""
281	1	xmlns=""""
282	1	xmlns:xs=""http://www.w3.org/2001/XMLSchema""
283	1	xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
284	1	<xs:element name=""MyDataSet"" msdata:IsDataSet=""true"">
285	1	<xs:complexType>
286	1	<xs:choice maxOccurs=""unbounded"">
287	1	<xs:element name=""customers"" >
288	1	<xs:complexType >
289	1	<xs:sequence>
290	1	<xs:element name=""CustomerID"" type=""xs:integer""
291	1	minOccurs=""0"" />
292	1	<xs:element name=""CompanyName"" type=""xs:string""
293	1	minOccurs=""0"" />
294	1	<xs:element name=""Phone"" type=""xs:string"" />
295	1	</xs:sequence>
296	1	</xs:complexType>
297	1	</xs:element>
298	1	</xs:choice>
299	1	</xs:complexType>
300	1	</xs:element>
301	1	</xs:schema>";
302
303	1	XmlDocument doc = new XmlDocument();
304	1	doc.LoadXml(xml);
305
306	1	string jsonText = SerializeXmlNode(doc);
307
308	1	string expected = @"{
309	1	""?xml"": {
310	1	""@version"": ""1.0"",
311	1	""@encoding"": ""utf-8""
312	1	},
313	1	""xs:schema"": {
314	1	""@xs:id"": ""SomeID"",
315	1	""@xmlns"": """",
316	1	""@xmlns:xs"": ""http://www.w3.org/2001/XMLSchema"",
317	1	""@xmlns:msdata"": ""urn:schemas-microsoft-com:xml-msdata"",
318	1	""xs:element"": {
319	1	""@name"": ""MyDataSet"",
320	1	""@msdata:IsDataSet"": ""true"",
321	1	""xs:complexType"": {
322	1	""xs:choice"": {
323	1	""@maxOccurs"": ""unbounded"",
324	1	""xs:element"": {
325	1	""@name"": ""customers"",
326	1	""xs:complexType"": {
327	1	""xs:sequence"": {
328	1	""xs:element"": [
329	1	{
330	1	""@name"": ""CustomerID"",
331	1	""@type"": ""xs:integer"",
332	1	""@minOccurs"": ""0""
333	1	},
334	1	{
335	1	""@name"": ""CompanyName"",
336	1	""@type"": ""xs:string"",
337	1	""@minOccurs"": ""0""
338	1	},
339	1	{
340	1	""@name"": ""Phone"",
341	1	""@type"": ""xs:string""
342	1	}
343	1	]
344	1	}
345	1	}
346	1	}
347	1	}
348	1	}
349	1	}
350	1	}
351	1	}";
352
353	1	Assert.AreEqual(expected, jsonText);
354
355	1	XmlDocument deserializedDoc = (XmlDocument)DeserializeXmlNode(jsonText);
356
357	1	Assert.AreEqual(doc.InnerXml, deserializedDoc.InnerXml);
358
359	1	Console.WriteLine("NamespaceSerializeDeserialize");
360	1	Console.WriteLine(jsonText);
361	1	Console.WriteLine(deserializedDoc.InnerXml);
362	1	Console.WriteLine();
363	1	}
364
365		[Test]
366		public void DocumentDeserialize()
367		{
368	1	string jsonText = @"{
369	1	""?xml"": {
370	1	""@version"": ""1.0"",
371	1	""@standalone"": ""no""
372	1	},
373	1	""span"": {
374	1	""@class"": ""vevent"",
375	1	""a"": {
376	1	""@class"": ""url"",
377	1	""@href"": ""http://www.web2con.com/"",
378	1	""span"": {
379	1	""@class"": ""summary"",
380	1	""#text"": ""Web 2.0 Conference"",
381	1	""#cdata-section"": ""my escaped text""
382	1	}
383	1	}
384	1	}
385	1	}";
386
387	1	XmlDocument doc = (XmlDocument)DeserializeXmlNode(jsonText);
388
389	1	string expected = @"<?xml version=""1.0"" standalone=""no""?>
390	1	<span class=""vevent"">
391	1	<a class=""url"" href=""http://www.web2con.com/"">
392	1	<span class=""summary"">Web 2.0 Conference<![CDATA[my escaped text]]></span>
393	1	</a>
394	1	</span>";
395
396	1	string formattedXml = GetIndentedInnerXml(doc);
397
398	1	Console.WriteLine("DocumentDeserialize");
399	1	Console.WriteLine(formattedXml);
400	1	Console.WriteLine();
401
402	1	Assert.AreEqual(expected, formattedXml);
403	1	}
404
405		private string GetIndentedInnerXml(XmlNode node)
406		{
407	2	XmlWriterSettings settings = new XmlWriterSettings();
408	2	settings.Indent = true;
409
410	2	StringWriter sw = new StringWriter();
411
412	2	using (XmlWriter writer = XmlWriter.Create(sw, settings))
413		{
414	2	node.WriteTo(writer);
415		}
416
417	2	return sw.ToString();
418	2	}
419
420		[Test]
421		public void SingleTextNode()
422		{
423	1	string xml = @"<?xml version=""1.0"" standalone=""no""?>
424	1	<root>
425	1	<person id=""1"">
426	1	<name>Alan</name>
427	1	<url>http://www.google.com</url>
428	1	</person>
429	1	<person id=""2"">
430	1	<name>Louis</name>
431	1	<url>http://www.yahoo.com</url>
432	1	</person>
433	1	</root>";
434
435	1	XmlDocument doc = new XmlDocument();
436	1	doc.LoadXml(xml);
437
438	1	string jsonText = SerializeXmlNode(doc);
439
440	1	XmlDocument newDoc = (XmlDocument)DeserializeXmlNode(jsonText);
441
442	1	Assert.AreEqual(doc.InnerXml, newDoc.InnerXml);
443	1	}
444
445		[Test]
446		public void EmptyNode()
447		{
448	1	string xml = @"<?xml version=""1.0"" standalone=""no""?>
449	1	<root>
450	1	<person id=""1"">
451	1	<name>Alan</name>
452	1	<url />
453	1	</person>
454	1	<person id=""2"">
455	1	<name>Louis</name>
456	1	<url>http://www.yahoo.com</url>
457	1	</person>
458	1	</root>";
459
460	1	XmlDocument doc = new XmlDocument();
461	1	doc.LoadXml(xml);
462
463	1	string jsonText = SerializeXmlNode(doc);
464
465	1	Console.WriteLine(jsonText);
466
467	1	XmlDocument newDoc = (XmlDocument)DeserializeXmlNode(jsonText);
468
469	1	Assert.AreEqual(doc.InnerXml, newDoc.InnerXml);
470	1	}
471
472		[Test]
473		public void OtherElementDataTypes()
474		{
475	1	string jsonText = @"{""?xml"":{""@version"":""1.0"",""@standalone"":""no""},""root"":{""person"":[{""@id"":""1"",""Float"":2.5,""Integer"":99},{""@id"":""2"",""Boolean"":true,""date"":""\/Date(954374400000)\/""}]}}";
476
477	1	XmlDocument newDoc = (XmlDocument)DeserializeXmlNode(jsonText);
478
479	1	string expected = @"<?xml version=""1.0"" standalone=""no""?><root><person id=""1""><Float>2.5</Float><Integer>99</Integer></person><person id=""2""><Boolean>true</Boolean><date>2000-03-30T00:00:00Z</date></person></root>";
480
481	1	Assert.AreEqual(expected, newDoc.InnerXml);
482	1	}
483
484		[Test]
485		[ExpectedException(typeof(JsonSerializationException), ExpectedMessage = "XmlNodeConverter can only convert JSON that begins with an object.")]
486		public void NoRootObject()
487		{
488	1	XmlDocument newDoc = (XmlDocument)JsonConvert.DeserializeXmlNode(@"[1]");
489	0	}
490
491		[Test]
492		[ExpectedException(typeof(JsonSerializationException), ExpectedMessage = "JSON root object has multiple properties. The root object must have a single property in order to create a valid XML document. Consider specifing a DeserializeRootElementName.")]
493		public void RootObjectMultipleProperties()
494		{
495	1	XmlDocument newDoc = (XmlDocument)JsonConvert.DeserializeXmlNode(@"{Prop1:1,Prop2:2}");
496	0	}
497
498		[Test]
499		public void JavaScriptConstructor()
500		{