Files
mono/mcs/class/System.XML/Test/System.Xml.Serialization/XmlSerializerTests.cs
T
Marcos Henrich 007413298d Test Xml serialization of a property with attribute XmlText.
The tested property has a default value that is not null.
Covers 18908.
2014-09-26 10:31:51 +01:00

3575 lines
137 KiB
C#

//
// System.Xml.XmlSerializerTests
//
// Author:
// Erik LeBel <[email protected]>
// Hagit Yidov <[email protected]>
//
// (C) 2003 Erik LeBel
// (C) 2005 Mainsoft Corporation (http://www.mainsoft.com)
//
//
// NOTES:
// Where possible, these tests avoid testing the order of
// an object's members serialization. Mono and .NET do not
// reflect members in the same order.
//
// Only serializations tests so far, no deserialization.
//
// FIXME
// test XmlArrayAttribute
// test XmlArrayItemAttribute
// test serialization of decimal type
// test serialization of Guid type
// test XmlNode serialization with and without modifying attributes.
// test deserialization
// FIXMEs found in this file
using System;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Text;
using System.Xml;
using System.Data;
using System.Xml.Schema;
using System.Xml.Serialization;
using System.Reflection;
#if NET_2_0
using System.Collections.Generic;
#endif
using NUnit.Framework;
using MonoTests.System.Xml.TestClasses;
namespace MonoTests.System.XmlSerialization
{
[TestFixture]
public class XmlSerializerTests
{
const string SoapEncodingNamespace = "http://schemas.xmlsoap.org/soap/encoding/";
const string WsdlTypesNamespace = "http://microsoft.com/wsdl/types/";
const string ANamespace = "some:urn";
const string AnotherNamespace = "another:urn";
StringWriter sw;
XmlTextWriter xtw;
XmlSerializer xs;
private void SetUpWriter ()
{
sw = new StringWriter ();
xtw = new XmlTextWriter (sw);
xtw.QuoteChar = '\'';
xtw.Formatting = Formatting.None;
}
private string WriterText
{
get
{
string val = sw.GetStringBuilder ().ToString ();
int offset = val.IndexOf ('>') + 1;
val = val.Substring (offset);
return Infoset (val);
}
}
private void Serialize (object o)
{
SetUpWriter ();
xs = new XmlSerializer (o.GetType ());
xs.Serialize (xtw, o);
}
private void Serialize (object o, Type type)
{
SetUpWriter ();
xs = new XmlSerializer (type);
xs.Serialize (xtw, o);
}
private void Serialize (object o, XmlSerializerNamespaces ns)
{
SetUpWriter ();
xs = new XmlSerializer (o.GetType ());
xs.Serialize (xtw, o, ns);
}
private void Serialize (object o, XmlAttributeOverrides ao)
{
SetUpWriter ();
xs = new XmlSerializer (o.GetType (), ao);
xs.Serialize (xtw, o);
}
private void Serialize (object o, XmlAttributeOverrides ao, string defaultNamespace)
{
SetUpWriter ();
xs = new XmlSerializer (o.GetType (), ao, Type.EmptyTypes,
(XmlRootAttribute) null, defaultNamespace);
xs.Serialize (xtw, o);
}
private void Serialize (object o, XmlRootAttribute root)
{
SetUpWriter ();
xs = new XmlSerializer (o.GetType (), root);
xs.Serialize (xtw, o);
}
private void Serialize (object o, XmlTypeMapping typeMapping)
{
SetUpWriter ();
xs = new XmlSerializer (typeMapping);
xs.Serialize (xtw, o);
}
private void SerializeEncoded (object o)
{
SerializeEncoded (o, o.GetType ());
}
private void SerializeEncoded (object o, SoapAttributeOverrides ao)
{
XmlTypeMapping mapping = CreateSoapMapping (o.GetType (), ao);
SetUpWriter ();
xs = new XmlSerializer (mapping);
xs.Serialize (xtw, o);
}
private void SerializeEncoded (object o, SoapAttributeOverrides ao, string defaultNamespace)
{
XmlTypeMapping mapping = CreateSoapMapping (o.GetType (), ao, defaultNamespace);
SetUpWriter ();
xs = new XmlSerializer (mapping);
xs.Serialize (xtw, o);
}
private void SerializeEncoded (object o, Type type)
{
XmlTypeMapping mapping = CreateSoapMapping (type);
SetUpWriter ();
xs = new XmlSerializer (mapping);
xs.Serialize (xtw, o);
}
private void SerializeEncoded (XmlTextWriter xtw, object o, Type type)
{
XmlTypeMapping mapping = CreateSoapMapping (type);
xs = new XmlSerializer (mapping);
xs.Serialize (xtw, o);
}
// test constructors
#if USE_VERSION_1_1 // It doesn't pass on MS.NET 1.1.
[Test]
public void TestConstructor()
{
XmlSerializer ser = new XmlSerializer (null, "");
}
#else
#endif
// test basic types ////////////////////////////////////////////////////////
[Test]
public void TestSerializeInt ()
{
Serialize (10);
Assert.AreEqual (Infoset ("<int>10</int>"), WriterText);
}
[Test]
public void TestSerializeBool ()
{
Serialize (true);
Assert.AreEqual (Infoset ("<boolean>true</boolean>"), WriterText);
Serialize (false);
Assert.AreEqual (Infoset ("<boolean>false</boolean>"), WriterText);
}
[Test]
public void TestSerializeString ()
{
Serialize ("hello");
Assert.AreEqual (Infoset ("<string>hello</string>"), WriterText);
}
[Test]
public void TestSerializeEmptyString ()
{
Serialize (String.Empty);
Assert.AreEqual (Infoset ("<string />"), WriterText);
}
[Test]
public void TestSerializeNullObject ()
{
Serialize (null, typeof (object));
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<anyType xmlns:xsd='{0}' xmlns:xsi='{1}' xsi:nil='true' />",
XmlSchema.Namespace, XmlSchema.InstanceNamespace)), WriterText);
}
[Test]
[Ignore ("The generated XML is not exact but it is equivalent")]
public void TestSerializeNullString ()
{
Serialize (null, typeof (string));
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<string xmlns:xsd='{0}' xmlns:xsi='{1}' xsi:nil='true' />",
XmlSchema.Namespace, XmlSchema.InstanceNamespace)), WriterText);
}
[Test]
public void TestSerializeIntArray ()
{
Serialize (new int[] { 1, 2, 3, 4 });
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<ArrayOfInt xmlns:xsd='{0}' xmlns:xsi='{1}'><int>1</int><int>2</int><int>3</int><int>4</int></ArrayOfInt>",
XmlSchema.Namespace, XmlSchema.InstanceNamespace)), WriterText);
}
[Test]
public void TestSerializeEmptyArray ()
{
Serialize (new int[] { });
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<ArrayOfInt xmlns:xsd='{0}' xmlns:xsi='{1}' />",
XmlSchema.Namespace, XmlSchema.InstanceNamespace)), WriterText);
}
[Test]
public void TestSerializeChar ()
{
Serialize ('A');
Assert.AreEqual (Infoset ("<char>65</char>"), WriterText);
Serialize ('\0');
Assert.AreEqual (Infoset ("<char>0</char>"), WriterText);
Serialize ('\n');
Assert.AreEqual (Infoset ("<char>10</char>"), WriterText);
Serialize ('\uFF01');
Assert.AreEqual (Infoset ("<char>65281</char>"), WriterText);
}
[Test]
public void TestSerializeFloat ()
{
Serialize (10.78);
Assert.AreEqual (Infoset ("<double>10.78</double>"), WriterText);
Serialize (-1e8);
Assert.AreEqual (Infoset ("<double>-100000000</double>"), WriterText);
// FIXME test INF and other boundary conditions that may exist with floats
}
[Test]
public void TestSerializeEnumeration_FromValue ()
{
Serialize ((int) SimpleEnumeration.SECOND, typeof (SimpleEnumeration));
Assert.AreEqual (
"<?xml version='1.0' encoding='utf-16'?>" +
"<SimpleEnumeration>SECOND</SimpleEnumeration>",
sw.ToString ());
}
[Test]
[Category ("NotWorking")]
public void TestSerializeEnumeration_FromValue_Encoded ()
{
SerializeEncoded ((int) SimpleEnumeration.SECOND, typeof (SimpleEnumeration));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<SimpleEnumeration d1p1:type='SimpleEnumeration' xmlns:d1p1='{0}'>SECOND</SimpleEnumeration>",
XmlSchema.InstanceNamespace), sw.ToString ());
}
[Test]
public void TestSerializeEnumeration ()
{
Serialize (SimpleEnumeration.FIRST);
Assert.AreEqual (Infoset ("<SimpleEnumeration>FIRST</SimpleEnumeration>"), WriterText, "#1");
Serialize (SimpleEnumeration.SECOND);
Assert.AreEqual (Infoset ("<SimpleEnumeration>SECOND</SimpleEnumeration>"), WriterText, "#2");
}
[Test]
public void TestSerializeEnumeration_Encoded ()
{
SerializeEncoded (SimpleEnumeration.FIRST);
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<SimpleEnumeration d1p1:type='SimpleEnumeration' xmlns:d1p1='{0}'>FIRST</SimpleEnumeration>",
XmlSchema.InstanceNamespace), sw.ToString (), "#B1");
SerializeEncoded (SimpleEnumeration.SECOND);
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<SimpleEnumeration d1p1:type='SimpleEnumeration' xmlns:d1p1='{0}'>SECOND</SimpleEnumeration>",
XmlSchema.InstanceNamespace), sw.ToString (), "#B2");
}
[Test]
public void TestSerializeEnumDefaultValue ()
{
Serialize (new EnumDefaultValue ());
Assert.AreEqual (Infoset ("<EnumDefaultValue />"), WriterText, "#1");
Serialize (new SimpleEnumeration ());
Assert.AreEqual (Infoset ("<SimpleEnumeration>FIRST</SimpleEnumeration>"), WriterText, "#2");
Serialize (3, typeof (EnumDefaultValue));
Assert.AreEqual (Infoset ("<EnumDefaultValue>e3</EnumDefaultValue>"), WriterText, "#3");
Serialize (EnumDefaultValue.e3, typeof (EnumDefaultValue));
Assert.AreEqual (Infoset ("<EnumDefaultValue>e3</EnumDefaultValue>"), WriterText, "#4");
Serialize (EnumDefaultValue.e1 | EnumDefaultValue.e2, typeof (EnumDefaultValue));
Assert.AreEqual (Infoset ("<EnumDefaultValue>e3</EnumDefaultValue>"), WriterText, "#5");
Serialize (EnumDefaultValue.e1 | EnumDefaultValue.e2 | EnumDefaultValue.e3, typeof (EnumDefaultValue));
Assert.AreEqual (Infoset ("<EnumDefaultValue>e3</EnumDefaultValue>"), WriterText, "#6");
Serialize (EnumDefaultValue.e1 | EnumDefaultValue.e3, typeof (EnumDefaultValue));
Assert.AreEqual (Infoset ("<EnumDefaultValue>e3</EnumDefaultValue>"), WriterText, "#7");
Serialize (EnumDefaultValue.e2 | EnumDefaultValue.e3, typeof (EnumDefaultValue));
Assert.AreEqual (Infoset ("<EnumDefaultValue>e3</EnumDefaultValue>"), WriterText, "#8");
Serialize (3, typeof (FlagEnum));
Assert.AreEqual (Infoset ("<FlagEnum>one two</FlagEnum>"), WriterText, "#9");
Serialize (5, typeof (FlagEnum));
Assert.AreEqual (Infoset ("<FlagEnum>one four</FlagEnum>"), WriterText, "#10");
Serialize (FlagEnum.e4, typeof (FlagEnum));
Assert.AreEqual (Infoset ("<FlagEnum>four</FlagEnum>"), WriterText, "#11");
Serialize (FlagEnum.e1 | FlagEnum.e2, typeof (FlagEnum));
Assert.AreEqual (Infoset ("<FlagEnum>one two</FlagEnum>"), WriterText, "#12");
Serialize (FlagEnum.e1 | FlagEnum.e2 | FlagEnum.e4, typeof (FlagEnum));
Assert.AreEqual (Infoset ("<FlagEnum>one two four</FlagEnum>"), WriterText, "#13");
Serialize (FlagEnum.e1 | FlagEnum.e4, typeof (FlagEnum));
Assert.AreEqual (Infoset ("<FlagEnum>one four</FlagEnum>"), WriterText, "#14");
Serialize (FlagEnum.e2 | FlagEnum.e4, typeof (FlagEnum));
Assert.AreEqual (Infoset ("<FlagEnum>two four</FlagEnum>"), WriterText, "#15");
Serialize (3, typeof (EnumDefaultValueNF));
Assert.AreEqual (Infoset ("<EnumDefaultValueNF>e3</EnumDefaultValueNF>"), WriterText, "#16");
Serialize (EnumDefaultValueNF.e2, typeof (EnumDefaultValueNF));
Assert.AreEqual (Infoset ("<EnumDefaultValueNF>e2</EnumDefaultValueNF>"), WriterText, "#17");
Serialize (2, typeof (ZeroFlagEnum));
Assert.AreEqual (Infoset ("<ZeroFlagEnum>tns:t&lt;w&gt;o</ZeroFlagEnum>"), WriterText, "#18");
Serialize (new ZeroFlagEnum ()); // enum actually has a field with value 0
Assert.AreEqual (Infoset ("<ZeroFlagEnum>zero</ZeroFlagEnum>"), WriterText, "#19");
}
[Test]
[Category ("NotWorking")]
public void TestSerializeEnumDefaultValue_Encoded ()
{
SerializeEncoded (new EnumDefaultValue ());
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<EnumDefaultValue d1p1:type='EnumDefaultValue' xmlns:d1p1='{0}' />",
XmlSchema.InstanceNamespace), sw.ToString (), "#1");
SerializeEncoded (new SimpleEnumeration ());
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<SimpleEnumeration d1p1:type='SimpleEnumeration' xmlns:d1p1='{0}'>FIRST</SimpleEnumeration>",
XmlSchema.InstanceNamespace), sw.ToString (), "#2");
SerializeEncoded (3, typeof (EnumDefaultValue));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<EnumDefaultValue d1p1:type='EnumDefaultValue' xmlns:d1p1='{0}'>e3</EnumDefaultValue>",
XmlSchema.InstanceNamespace), sw.ToString (), "#3");
SerializeEncoded (EnumDefaultValue.e3, typeof (EnumDefaultValue));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<EnumDefaultValue d1p1:type='EnumDefaultValue' xmlns:d1p1='{0}'>e3</EnumDefaultValue>",
XmlSchema.InstanceNamespace), sw.ToString (), "#4");
SerializeEncoded (EnumDefaultValue.e1 | EnumDefaultValue.e2, typeof (EnumDefaultValue));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<EnumDefaultValue d1p1:type='EnumDefaultValue' xmlns:d1p1='{0}'>e3</EnumDefaultValue>",
XmlSchema.InstanceNamespace), sw.ToString (), "#5");
SerializeEncoded (EnumDefaultValue.e1 | EnumDefaultValue.e2 | EnumDefaultValue.e3, typeof (EnumDefaultValue));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<EnumDefaultValue d1p1:type='EnumDefaultValue' xmlns:d1p1='{0}'>e3</EnumDefaultValue>",
XmlSchema.InstanceNamespace), sw.ToString (), "#6");
SerializeEncoded (EnumDefaultValue.e1 | EnumDefaultValue.e3, typeof (EnumDefaultValue));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<EnumDefaultValue d1p1:type='EnumDefaultValue' xmlns:d1p1='{0}'>e3</EnumDefaultValue>",
XmlSchema.InstanceNamespace), sw.ToString (), "#7");
SerializeEncoded (EnumDefaultValue.e2 | EnumDefaultValue.e3, typeof (EnumDefaultValue));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<EnumDefaultValue d1p1:type='EnumDefaultValue' xmlns:d1p1='{0}'>e3</EnumDefaultValue>",
XmlSchema.InstanceNamespace), sw.ToString (), "#8");
SerializeEncoded (3, typeof (FlagEnum));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<FlagEnum d1p1:type='FlagEnum' xmlns:d1p1='{0}'>e1 e2</FlagEnum>",
XmlSchema.InstanceNamespace), sw.ToString (), "#9");
SerializeEncoded (5, typeof (FlagEnum));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<FlagEnum d1p1:type='FlagEnum' xmlns:d1p1='{0}'>e1 e4</FlagEnum>",
XmlSchema.InstanceNamespace), sw.ToString (), "#10");
SerializeEncoded (FlagEnum.e4, typeof (FlagEnum));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<FlagEnum d1p1:type='FlagEnum' xmlns:d1p1='{0}'>e4</FlagEnum>",
XmlSchema.InstanceNamespace), sw.ToString (), "#11");
SerializeEncoded (FlagEnum.e1 | FlagEnum.e2, typeof (FlagEnum));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<FlagEnum d1p1:type='FlagEnum' xmlns:d1p1='{0}'>e1 e2</FlagEnum>",
XmlSchema.InstanceNamespace), sw.ToString (), "#12");
SerializeEncoded (FlagEnum.e1 | FlagEnum.e2 | FlagEnum.e4, typeof (FlagEnum));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<FlagEnum d1p1:type='FlagEnum' xmlns:d1p1='{0}'>e1 e2 e4</FlagEnum>",
XmlSchema.InstanceNamespace), sw.ToString (), "#13");
SerializeEncoded (FlagEnum.e1 | FlagEnum.e4, typeof (FlagEnum));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<FlagEnum d1p1:type='FlagEnum' xmlns:d1p1='{0}'>e1 e4</FlagEnum>",
XmlSchema.InstanceNamespace), sw.ToString (), "#14");
SerializeEncoded (FlagEnum.e2 | FlagEnum.e4, typeof (FlagEnum));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<FlagEnum d1p1:type='FlagEnum' xmlns:d1p1='{0}'>e2 e4</FlagEnum>",
XmlSchema.InstanceNamespace), sw.ToString (), "#15");
SerializeEncoded (3, typeof (EnumDefaultValueNF));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<EnumDefaultValueNF d1p1:type='EnumDefaultValueNF' xmlns:d1p1='{0}'>e3</EnumDefaultValueNF>",
XmlSchema.InstanceNamespace), sw.ToString (), "#16");
SerializeEncoded (EnumDefaultValueNF.e2, typeof (EnumDefaultValueNF));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<EnumDefaultValueNF d1p1:type='EnumDefaultValueNF' xmlns:d1p1='{0}'>e2</EnumDefaultValueNF>",
XmlSchema.InstanceNamespace), sw.ToString (), "#17");
SerializeEncoded (2, typeof (ZeroFlagEnum));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<ZeroFlagEnum d1p1:type='ZeroFlagEnum' xmlns:d1p1='{0}'>e2</ZeroFlagEnum>",
XmlSchema.InstanceNamespace), sw.ToString (), "#18");
SerializeEncoded (new ZeroFlagEnum ()); // enum actually has a field with value 0
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<ZeroFlagEnum d1p1:type='ZeroFlagEnum' xmlns:d1p1='{0}'>e0</ZeroFlagEnum>",
XmlSchema.InstanceNamespace), sw.ToString (), "#19");
}
[Test]
public void TestSerializeEnumDefaultValue_InvalidValue1 ()
{
try {
Serialize ("b", typeof (EnumDefaultValue));
Assert.Fail ("#A1");
} catch (InvalidOperationException ex) {
Assert.IsNotNull (ex.InnerException, "#A2");
Assert.AreEqual (typeof (InvalidCastException), ex.InnerException.GetType (), "#A3");
}
try {
Serialize ("e1", typeof (EnumDefaultValue));
Assert.Fail ("#B1");
} catch (InvalidOperationException ex) {
Assert.IsNotNull (ex.InnerException, "#B2");
Assert.AreEqual (typeof (InvalidCastException), ex.InnerException.GetType (), "#B3");
}
try {
Serialize ("e1,e2", typeof (EnumDefaultValue));
Assert.Fail ("#C1");
} catch (InvalidOperationException ex) {
Assert.IsNotNull (ex.InnerException, "#C2");
Assert.AreEqual (typeof (InvalidCastException), ex.InnerException.GetType (), "#C3");
}
try {
Serialize (string.Empty, typeof (EnumDefaultValue));
Assert.Fail ("#D1");
} catch (InvalidOperationException ex) {
Assert.IsNotNull (ex.InnerException, "#D2");
Assert.AreEqual (typeof (InvalidCastException), ex.InnerException.GetType (), "#D3");
}
try {
Serialize ("1", typeof (EnumDefaultValue));
Assert.Fail ("#E1");
} catch (InvalidOperationException ex) {
Assert.IsNotNull (ex.InnerException, "#E2");
Assert.AreEqual (typeof (InvalidCastException), ex.InnerException.GetType (), "#E3");
}
try {
Serialize ("0", typeof (EnumDefaultValue));
Assert.Fail ("#F1");
} catch (InvalidOperationException ex) {
Assert.IsNotNull (ex.InnerException, "#F2");
Assert.AreEqual (typeof (InvalidCastException), ex.InnerException.GetType (), "#F3");
}
try {
Serialize (new SimpleClass (), typeof (EnumDefaultValue));
Assert.Fail ("#G1");
} catch (InvalidOperationException ex) {
Assert.IsNotNull (ex.InnerException, "#G2");
Assert.AreEqual (typeof (InvalidCastException), ex.InnerException.GetType (), "#G3");
}
}
[Test]
public void TestSerializeEnumDefaultValue_InvalidValue2 ()
{
#if NET_2_0
try {
Serialize (5, typeof (EnumDefaultValue));
Assert.Fail ("#1");
} catch (InvalidOperationException ex) {
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
Assert.IsNotNull (ex.InnerException, "#3");
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#4");
Assert.IsNotNull (ex.InnerException.Message, "#5");
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'5'") != -1, "#6");
Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValue).FullName) != -1, "#7");
}
#else
Serialize (5, typeof (EnumDefaultValue));
Assert.AreEqual (Infoset ("<EnumDefaultValue>5</EnumDefaultValue>"), WriterText);
#endif
}
[Test]
public void TestSerializeEnumDefaultValueNF_InvalidValue1 ()
{
#if NET_2_0
try {
Serialize (new EnumDefaultValueNF ());
Assert.Fail ("#1");
} catch (InvalidOperationException ex) {
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
Assert.IsNotNull (ex.InnerException, "#3");
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#4");
Assert.IsNotNull (ex.InnerException.Message, "#5");
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'0'") != -1, "#6");
Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).FullName) != -1, "#7");
}
#else
Serialize (new EnumDefaultValueNF ());
Assert.AreEqual (Infoset ("<EnumDefaultValueNF>0</EnumDefaultValueNF>"), WriterText);
#endif
}
[Test]
public void TestSerializeEnumDefaultValueNF_InvalidValue2 ()
{
#if NET_2_0
try {
Serialize (15, typeof (EnumDefaultValueNF));
Assert.Fail ("#1");
} catch (InvalidOperationException ex) {
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
Assert.IsNotNull (ex.InnerException, "#3");
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#4");
Assert.IsNotNull (ex.InnerException.Message, "#5");
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'15'") != -1, "#6");
Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).FullName) != -1, "#7");
}
#else
Serialize (15, typeof (EnumDefaultValueNF));
Assert.AreEqual (Infoset ("<EnumDefaultValueNF>15</EnumDefaultValueNF>"), WriterText);
#endif
}
[Test]
public void TestSerializeEnumDefaultValueNF_InvalidValue3 ()
{
try {
Serialize ("b", typeof (EnumDefaultValueNF));
Assert.Fail ("#A1");
} catch (InvalidOperationException ex) {
Assert.IsNotNull (ex.InnerException, "#A2");
Assert.AreEqual (typeof (InvalidCastException), ex.InnerException.GetType (), "#A3");
}
try {
Serialize ("e2", typeof (EnumDefaultValueNF));
Assert.Fail ("#B1");
} catch (InvalidOperationException ex) {
Assert.IsNotNull (ex.InnerException, "#B2");
Assert.AreEqual (typeof (InvalidCastException), ex.InnerException.GetType (), "#B3");
}
try {
Serialize (string.Empty, typeof (EnumDefaultValueNF));
Assert.Fail ("#C1");
} catch (InvalidOperationException ex) {
Assert.IsNotNull (ex.InnerException, "#C2");
Assert.AreEqual (typeof (InvalidCastException), ex.InnerException.GetType (), "#C3");
}
try {
Serialize ("1", typeof (EnumDefaultValueNF));
Assert.Fail ("#D1");
} catch (InvalidOperationException ex) {
Assert.IsNotNull (ex.InnerException, "#D2");
Assert.AreEqual (typeof (InvalidCastException), ex.InnerException.GetType (), "#D3");
}
try {
Serialize ("0", typeof (EnumDefaultValueNF));
Assert.Fail ("#E1");
} catch (InvalidOperationException ex) {
Assert.IsNotNull (ex.InnerException, "#E2");
Assert.AreEqual (typeof (InvalidCastException), ex.InnerException.GetType (), "#E3");
}
}
[Test]
public void TestSerializeField ()
{
Field f = new Field ();
Serialize (f, typeof (Field));
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag1='' flag2='' flag3=''" +
" flag4='' modifiers='public' modifiers2='public' modifiers4='public' />",
XmlSchema.Namespace, XmlSchema.InstanceNamespace)), WriterText, "#A");
f.Flags1 = FlagEnum.e1;
f.Flags2 = FlagEnum.e1;
f.Flags3 = FlagEnum.e2;
f.Modifiers = MapModifiers.Protected;
f.Modifiers2 = MapModifiers.Public;
f.Modifiers3 = MapModifiers.Public;
f.Modifiers4 = MapModifiers.Protected;
f.Modifiers5 = MapModifiers.Public;
Serialize (f, typeof (Field));
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag3='two' flag4=''" +
" modifiers='protected' modifiers2='public' />",
XmlSchema.Namespace, XmlSchema.InstanceNamespace)), WriterText, "#B");
f.Flags1 = (FlagEnum) 1;
f.Flags1 = FlagEnum.e2;
f.Flags2 = FlagEnum.e2;
f.Flags3 = FlagEnum.e1 | FlagEnum.e2;
f.Modifiers = MapModifiers.Public;
f.Modifiers2 = MapModifiers.Protected;
f.Modifiers3 = MapModifiers.Protected;
f.Modifiers4 = MapModifiers.Public;
f.Modifiers5 = MapModifiers.Protected;
Serialize (f, typeof (Field));
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag1='two' flag2='two'" +
" flag4='' modifiers='public' modifiers2='protected'" +
" modifiers3='protected' modifiers4='public'" +
" modifiers5='protected' />",
XmlSchema.Namespace, XmlSchema.InstanceNamespace)), WriterText, "#C");
f.Flags1 = FlagEnum.e1 | FlagEnum.e2;
f.Flags2 = FlagEnum.e2;
f.Flags3 = FlagEnum.e4;
f.Flags4 = FlagEnum.e1 | FlagEnum.e2 | FlagEnum.e4;
f.Modifiers3 = MapModifiers.Public;
f.Modifiers4 = MapModifiers.Protected;
f.Modifiers5 = MapModifiers.Public;
f.Names = new string[] { "a", "b" };
Serialize (f, typeof (Field));
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag1='one two' flag2='two'" +
" flag3='four' flag4='one two four' modifiers='public'" +
" modifiers2='protected' names='a b' />",
XmlSchema.Namespace, XmlSchema.InstanceNamespace)), WriterText, "#D");
f.Flags2 = (FlagEnum) 444;
f.Flags3 = (FlagEnum) 555;
f.Modifiers = (MapModifiers) 666;
f.Modifiers2 = (MapModifiers) 777;
f.Modifiers3 = (MapModifiers) 0;
f.Modifiers4 = (MapModifiers) 888;
f.Modifiers5 = (MapModifiers) 999;
#if NET_2_0
try {
Serialize (f, typeof (Field));
Assert.Fail ("#E1");
} catch (InvalidOperationException ex) {
// There was an error generating the XML document
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
Assert.IsNotNull (ex.Message, "#E3");
Assert.IsNotNull (ex.InnerException, "#E4");
// Instance validation error: '444' is not a valid value for
// MonoTests.System.Xml.TestClasses.FlagEnum
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#E5");
Assert.IsNotNull (ex.InnerException.Message, "#E6");
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'444'") != -1, "#E7");
Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#E8");
Assert.IsNull (ex.InnerException.InnerException, "#E9");
}
#else
Serialize (f, typeof (Field));
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag1='one two' flag2='444'" +
" flag3='555' flag4='one two four' modifiers='666' modifiers2='777'" +
" modifiers4='888' modifiers5='999' names='a b' />",
XmlSchema.Namespace, XmlSchema.InstanceNamespace)), WriterText, "#E");
#endif
}
[Test]
[Category ("NotDotNet")] // MS bug
public void TestSerializeField_Encoded ()
{
Field_Encoded f = new Field_Encoded ();
SerializeEncoded (f, typeof (Field_Encoded));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
#if NET_2_0
"<q1:field xmlns:xsi='{1}' xmlns:xsd='{0}' id='id1' flag1=''" +
" flag2='' flag3='' flag4='' modifiers='PuBlIc'" +
" modifiers2='PuBlIc' modifiers4='PuBlIc' xmlns:q1='some:urn' />",
#else
"<q1:field xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' flag1=''" +
" flag2='' flag3='' flag4='' modifiers='PuBlIc'" +
" modifiers2='PuBlIc' modifiers4='PuBlIc' xmlns:q1='some:urn' />",
#endif
XmlSchema.Namespace, XmlSchema.InstanceNamespace),
sw.GetStringBuilder ().ToString (), "#A");
f.Flags1 = FlagEnum_Encoded.e1;
f.Flags2 = FlagEnum_Encoded.e1;
f.Flags3 = FlagEnum_Encoded.e2;
f.Modifiers = MapModifiers.Protected;
f.Modifiers2 = MapModifiers.Public;
f.Modifiers3 = MapModifiers.Public;
f.Modifiers4 = MapModifiers.Protected;
f.Modifiers5 = MapModifiers.Public;
SerializeEncoded (f, typeof (Field_Encoded));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
#if NET_2_0
"<q1:field xmlns:xsi='{1}' xmlns:xsd='{0}' id='id1' flag3='two'" +
" flag4='' modifiers='Protected' modifiers2='PuBlIc'" +
" xmlns:q1='some:urn' />",
#else
"<q1:field xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' flag3='two'" +
" flag4='' modifiers='Protected' modifiers2='PuBlIc'" +
" xmlns:q1='some:urn' />",
#endif
XmlSchema.Namespace, XmlSchema.InstanceNamespace),
sw.GetStringBuilder ().ToString (), "#B");
f.Flags1 = FlagEnum_Encoded.e2;
f.Flags2 = FlagEnum_Encoded.e2;
f.Flags3 = FlagEnum_Encoded.e1 | FlagEnum_Encoded.e2;
f.Modifiers = MapModifiers.Public;
f.Modifiers2 = MapModifiers.Protected;
f.Modifiers3 = MapModifiers.Protected;
f.Modifiers4 = MapModifiers.Public;
f.Modifiers5 = MapModifiers.Protected;
SerializeEncoded (f, typeof (Field_Encoded));
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
#if NET_2_0
"<q1:field xmlns:xsi='{1}' xmlns:xsd='{0}' id='id1' flag1='two'" +
" flag2='two' flag4='' modifiers='PuBlIc' modifiers2='Protected'" +
" modifiers3='Protected' modifiers4='PuBlIc' modifiers5='Protected'" +
" xmlns:q1='some:urn' />",
#else
"<q1:field xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' flag1='two'" +
" flag2='two' flag4='' modifiers='PuBlIc' modifiers2='Protected'" +
" modifiers3='Protected' modifiers4='PuBlIc' modifiers5='Protected'" +
" xmlns:q1='some:urn' />",
#endif
XmlSchema.Namespace, XmlSchema.InstanceNamespace),
sw.GetStringBuilder ().ToString (), "#C");
f.Flags1 = (FlagEnum_Encoded) 1;
f.Flags2 = (FlagEnum_Encoded) 444;
f.Flags3 = (FlagEnum_Encoded) 555;
f.Modifiers = (MapModifiers) 666;
f.Modifiers2 = (MapModifiers) 777;
f.Modifiers3 = (MapModifiers) 0;
f.Modifiers4 = (MapModifiers) 888;
f.Modifiers5 = (MapModifiers) 999;
#if NET_2_0
try {
#endif
SerializeEncoded (f, typeof (Field_Encoded));
#if NET_2_0
Assert.Fail ("#D1");
} catch (InvalidOperationException ex) {
// There was an error generating the XML document
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
Assert.IsNotNull (ex.Message, "#D3");
Assert.IsNotNull (ex.InnerException, "#D4");
// Instance validation error: '444' is not a valid value for
// MonoTests.System.Xml.TestClasses.FlagEnum_Encoded
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D5");
Assert.IsNotNull (ex.InnerException.Message, "#D6");
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'444'") != -1, "#D7");
Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum_Encoded).FullName) != -1, "#D8");
Assert.IsNull (ex.InnerException.InnerException, "#D9");
}
#else
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
"<q1:field xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' flag2='444'" +
" flag3='555' flag4='' modifiers='666' modifiers2='777'" +
" modifiers4='888' modifiers5='999' xmlns:q1='some:urn' />",
XmlSchema.Namespace, XmlSchema.InstanceNamespace),
sw.GetStringBuilder ().ToString (), "#D");
#endif
}
[Test]
public void TestSerializeGroup ()
{
Group myGroup = new Group ();
myGroup.GroupName = ".NET";
Byte[] hexByte = new Byte[] { 0x64, 0x32 };
myGroup.GroupNumber = hexByte;
DateTime myDate = new DateTime (2002, 5, 2);
myGroup.Today = myDate;
myGroup.PostitiveInt = "10000";
myGroup.IgnoreThis = true;
Car thisCar = (Car) myGroup.myCar ("1234566");
myGroup.MyVehicle = thisCar;
SetUpWriter ();
xtw.WriteStartDocument (true);
xtw.WriteStartElement ("Wrapper");
SerializeEncoded (xtw, myGroup, typeof (Group));
xtw.WriteEndElement ();
xtw.Close ();
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<Wrapper>" +
"<Group xmlns:xsd='{0}' xmlns:xsi='{1}' xmlns:d2p1='http://www.cpandl.com' CreationDate='2002-05-02' d2p1:GroupName='.NET' GroupNumber='ZDI=' id='id1'>" +
"<PosInt xsi:type='xsd:nonNegativeInteger'>10000</PosInt>" +
"<Grouptype xsi:type='GroupType'>Small</Grouptype>" +
"<MyVehicle href='#id2' />" +
"</Group>" +
"<Car xmlns:d2p1='{1}' id='id2' d2p1:type='Car'>" +
"<licenseNumber xmlns:q1='{0}' d2p1:type='q1:string'>1234566</licenseNumber>" +
"<makeDate xmlns:q2='{0}' d2p1:type='q2:date'>0001-01-01</makeDate>" +
"</Car>" +
"</Wrapper>",
XmlSchema.Namespace, XmlSchema.InstanceNamespace)),
WriterText, "#1");
myGroup.GroupName = null;
myGroup.Grouptype = GroupType.B;
myGroup.MyVehicle.licenseNumber = null;
myGroup.MyVehicle.weight = "450";
SetUpWriter ();
xtw.WriteStartDocument (true);
xtw.WriteStartElement ("Wrapper");
SerializeEncoded (xtw, myGroup, typeof (Group));
xtw.WriteEndElement ();
xtw.Close ();
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<Wrapper>" +
"<Group xmlns:xsd='{0}' xmlns:xsi='{1}' CreationDate='2002-05-02' GroupNumber='ZDI=' id='id1'>" +
"<PosInt xsi:type='xsd:nonNegativeInteger'>10000</PosInt>" +
"<Grouptype xsi:type='GroupType'>Large</Grouptype>" +
"<MyVehicle href='#id2' />" +
"</Group>" +
"<Car xmlns:d2p1='{1}' id='id2' d2p1:type='Car'>" +
"<makeDate xmlns:q1='{0}' d2p1:type='q1:date'>0001-01-01</makeDate>" +
"<weight xmlns:q2='{0}' d2p1:type='q2:string'>450</weight>" +
"</Car>" +
"</Wrapper>",
XmlSchema.Namespace, XmlSchema.InstanceNamespace)),
WriterText, "#2");
}
[Test]
public void TestSerializeZeroFlagEnum_InvalidValue ()
{
#if NET_2_0
try {
Serialize (4, typeof (ZeroFlagEnum)); // corresponding enum field is marked XmlIgnore
Assert.Fail ("#1");
} catch (InvalidOperationException ex) {
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
Assert.IsNotNull (ex.InnerException, "#3");
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#4");
Assert.IsNotNull (ex.InnerException.Message, "#5");
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'4'") != -1, "#6");
Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (ZeroFlagEnum).FullName) != -1, "#7");
}
#else
Serialize (4, typeof (ZeroFlagEnum)); // corresponding enum field is marked XmlIgnore
Assert.AreEqual (Infoset ("<ZeroFlagEnum>4</ZeroFlagEnum>"), WriterText);
#endif
}
[Test]
public void TestSerializeQualifiedName ()
{
Serialize (new XmlQualifiedName ("me", "home.urn"));
Assert.AreEqual (Infoset ("<QName xmlns:q1='home.urn'>q1:me</QName>"), WriterText);
}
[Test]
public void TestSerializeBytes ()
{
Serialize ((byte) 0xAB);
Assert.AreEqual (Infoset ("<unsignedByte>171</unsignedByte>"), WriterText);
Serialize ((byte) 15);
Assert.AreEqual (Infoset ("<unsignedByte>15</unsignedByte>"), WriterText);
}
[Test]
public void TestSerializeByteArrays ()
{
Serialize (new byte[] { });
Assert.AreEqual (Infoset ("<base64Binary />"), WriterText);
Serialize (new byte[] { 0xAB, 0xCD });
Assert.AreEqual (Infoset ("<base64Binary>q80=</base64Binary>"), WriterText);
}
[Test]
public void TestSerializeDateTime ()
{
DateTime d = new DateTime ();
Serialize (d);
TimeZone tz = TimeZone.CurrentTimeZone;
TimeSpan off = tz.GetUtcOffset (d);
string sp = string.Format ("{0}{1:00}:{2:00}", off.Ticks >= 0 ? "+" : "", off.Hours, off.Minutes);
#if NET_2_0
Assert.AreEqual (Infoset ("<dateTime>0001-01-01T00:00:00</dateTime>"), WriterText);
#else
Assert.AreEqual (Infoset ("<dateTime>0001-01-01T00:00:00.0000000" + sp + "</dateTime>"), WriterText);
#endif
}
/*
FIXME
- decimal
- Guid
- XmlNode objects
[Test]
public void TestSerialize()
{
Serialize();
Assert.AreEqual (WriterText, "");
}
*/
// test basic class serialization /////////////////////////////////////
[Test]
public void TestSerializeSimpleClass ()
{
SimpleClass simple = new SimpleClass ();
Serialize (simple);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
simple.something = "hello";
Serialize (simple);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>hello</something></SimpleClass>"), WriterText);
}
[Test]
public void TestSerializeStringCollection ()
{
StringCollection strings = new StringCollection ();
Serialize (strings);
Assert.AreEqual (Infoset ("<ArrayOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
strings.Add ("hello");
strings.Add ("goodbye");
Serialize (strings);
Assert.AreEqual (Infoset ("<ArrayOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><string>hello</string><string>goodbye</string></ArrayOfString>"), WriterText);
}
[Test]
public void TestSerializeOptionalValueTypeContainer ()
{
XmlAttributeOverrides overrides = new XmlAttributeOverrides ();
XmlAttributes attr;
OptionalValueTypeContainer optionalValue = new OptionalValueTypeContainer ();
Serialize (optionalValue);
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
#if NET_2_0
"<optionalValue xmlns:xsi='{1}' xmlns:xsd='{0}' xmlns='{2}' />",
#else
"<optionalValue xmlns:xsd='{0}' xmlns:xsi='{1}' xmlns='{2}' />",
#endif
XmlSchema.Namespace, XmlSchema.InstanceNamespace, AnotherNamespace),
sw.ToString (), "#1");
attr = new XmlAttributes ();
// remove the DefaultValue attribute on the Flags member
overrides.Add (typeof (OptionalValueTypeContainer), "Flags", attr);
// remove the DefaultValue attribute on the Attributes member
overrides.Add (typeof (OptionalValueTypeContainer), "Attributes", attr);
Serialize (optionalValue, overrides);
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
#if NET_2_0
"<optionalValue xmlns:xsi='{1}' xmlns:xsd='{0}' xmlns='{2}'>" +
#else
"<optionalValue xmlns:xsd='{0}' xmlns:xsi='{1}' xmlns='{2}'>" +
#endif
"<Attributes xmlns='{3}'>one four</Attributes>" +
"</optionalValue>", XmlSchema.Namespace, XmlSchema.InstanceNamespace,
AnotherNamespace, ANamespace), sw.ToString (), "#2");
optionalValue.FlagsSpecified = true;
Serialize (optionalValue, overrides);
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
#if NET_2_0
"<optionalValue xmlns:xsi='{1}' xmlns:xsd='{0}' xmlns='{2}'>" +
#else
"<optionalValue xmlns:xsd='{0}' xmlns:xsi='{1}' xmlns='{2}'>" +
#endif
"<Attributes xmlns='{3}'>one four</Attributes>" +
"<Flags xmlns='{3}'>one</Flags>" +
"</optionalValue>",
XmlSchema.Namespace, XmlSchema.InstanceNamespace, AnotherNamespace,
ANamespace), sw.ToString (), "#3");
}
[Test]
public void TestSerializePlainContainer ()
{
StringCollectionContainer container = new StringCollectionContainer ();
Serialize (container);
Assert.AreEqual (Infoset ("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><Messages /></StringCollectionContainer>"), WriterText);
container.Messages.Add ("hello");
container.Messages.Add ("goodbye");
Serialize (container);
Assert.AreEqual (Infoset ("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><Messages><string>hello</string><string>goodbye</string></Messages></StringCollectionContainer>"), WriterText);
}
[Test]
public void TestSerializeArrayContainer ()
{
ArrayContainer container = new ArrayContainer ();
Serialize (container);
Assert.AreEqual (Infoset ("<ArrayContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
container.items = new object[] { 10, 20 };
Serialize (container);
Assert.AreEqual (Infoset ("<ArrayContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' ><items><anyType xsi:type='xsd:int'>10</anyType><anyType xsi:type='xsd:int'>20</anyType></items></ArrayContainer>"), WriterText);
container.items = new object[] { 10, "hello" };
Serialize (container);
Assert.AreEqual (Infoset ("<ArrayContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' ><items><anyType xsi:type='xsd:int'>10</anyType><anyType xsi:type='xsd:string'>hello</anyType></items></ArrayContainer>"), WriterText);
}
[Test]
public void TestSerializeClassArrayContainer ()
{
ClassArrayContainer container = new ClassArrayContainer ();
Serialize (container);
Assert.AreEqual (Infoset ("<ClassArrayContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
SimpleClass simple1 = new SimpleClass ();
simple1.something = "hello";
SimpleClass simple2 = new SimpleClass ();
simple2.something = "hello";
container.items = new SimpleClass[2];
container.items[0] = simple1;
container.items[1] = simple2;
Serialize (container);
Assert.AreEqual (Infoset ("<ClassArrayContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' ><items><SimpleClass><something>hello</something></SimpleClass><SimpleClass><something>hello</something></SimpleClass></items></ClassArrayContainer>"), WriterText);
}
// test basic attributes ///////////////////////////////////////////////
[Test]
public void TestSerializeSimpleClassWithXmlAttributes ()
{
SimpleClassWithXmlAttributes simple = new SimpleClassWithXmlAttributes ();
Serialize (simple);
Assert.AreEqual (Infoset ("<simple xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
simple.something = "hello";
Serialize (simple);
Assert.AreEqual (Infoset ("<simple xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' member='hello' />"), WriterText);
}
// test overrides ///////////////////////////////////////////////////////
[Test]
public void TestSerializeSimpleClassWithOverrides ()
{
// Also tests XmlIgnore
XmlAttributeOverrides overrides = new XmlAttributeOverrides ();
XmlAttributes attr = new XmlAttributes ();
attr.XmlIgnore = true;
overrides.Add (typeof (SimpleClassWithXmlAttributes), "something", attr);
SimpleClassWithXmlAttributes simple = new SimpleClassWithXmlAttributes ();
simple.something = "hello";
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<simple xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
}
[Test]
public void TestSerializeSchema ()
{
XmlSchema schema = new XmlSchema ();
schema.Items.Add (new XmlSchemaAttribute ());
schema.Items.Add (new XmlSchemaAttributeGroup ());
schema.Items.Add (new XmlSchemaComplexType ());
schema.Items.Add (new XmlSchemaNotation ());
schema.Items.Add (new XmlSchemaSimpleType ());
schema.Items.Add (new XmlSchemaGroup ());
schema.Items.Add (new XmlSchemaElement ());
StringWriter sw = new StringWriter ();
XmlTextWriter xtw = new XmlTextWriter (sw);
xtw.QuoteChar = '\'';
xtw.Formatting = Formatting.Indented;
XmlSerializer xs = new XmlSerializer (schema.GetType ());
xs.Serialize (xtw, schema);
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>{0}" +
"<xsd:schema xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xsd='http://www.w3.org/2001/XMLSchema'>{0}" +
" <xsd:attribute />{0}" +
" <xsd:attributeGroup />{0}" +
" <xsd:complexType />{0}" +
" <xsd:notation />{0}" +
" <xsd:simpleType />{0}" +
" <xsd:group />{0}" +
" <xsd:element />{0}" +
"</xsd:schema>", Environment.NewLine), sw.ToString ());
}
// test xmlText //////////////////////////////////////////////////////////
[Test]
public void TestSerializeXmlTextAttribute ()
{
SimpleClass simple = new SimpleClass ();
simple.something = "hello";
XmlAttributeOverrides overrides = new XmlAttributeOverrides ();
XmlAttributes attr = new XmlAttributes ();
overrides.Add (typeof (SimpleClass), "something", attr);
attr.XmlText = new XmlTextAttribute ();
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>hello</SimpleClass>"), WriterText, "#1");
attr.XmlText = new XmlTextAttribute (typeof (string));
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>hello</SimpleClass>"), WriterText, "#2");
try {
attr.XmlText = new XmlTextAttribute (typeof (byte[]));
Serialize (simple, overrides);
Assert.Fail ("#A1: XmlText.Type does not match the type it serializes: this should have failed");
} catch (InvalidOperationException ex) {
// there was an error reflecting type 'MonoTests.System.Xml.TestClasses.SimpleClass'
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
Assert.IsNotNull (ex.Message, "#A3");
Assert.IsTrue (ex.Message.IndexOf (typeof (SimpleClass).FullName) != -1, "#A4");
Assert.IsNotNull (ex.InnerException, "#A5");
// there was an error reflecting field 'something'.
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#A6");
Assert.IsNotNull (ex.InnerException.Message, "#A7");
Assert.IsTrue (ex.InnerException.Message.IndexOf ("something") != -1, "#A8");
Assert.IsNotNull (ex.InnerException.InnerException, "#A9");
// the type for XmlText may not be specified for primitive types.
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.InnerException.GetType (), "#A10");
Assert.IsNotNull (ex.InnerException.InnerException.Message, "#A11");
Assert.IsNull (ex.InnerException.InnerException.InnerException, "#A12");
}
try {
attr.XmlText = new XmlTextAttribute ();
attr.XmlText.DataType = "sometype";
Serialize (simple, overrides);
Assert.Fail ("#B1: XmlText.DataType does not match the type it serializes: this should have failed");
} catch (InvalidOperationException ex) {
// There was an error reflecting type 'MonoTests.System.Xml.TestClasses.SimpleClass'.
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
Assert.IsNotNull (ex.Message, "#B3");
Assert.IsTrue (ex.Message.IndexOf (typeof (SimpleClass).FullName) != -1, "#B4");
Assert.IsNotNull (ex.InnerException, "#B5");
// There was an error reflecting field 'something'.
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#B6");
Assert.IsNotNull (ex.InnerException.Message, "#B7");
Assert.IsTrue (ex.InnerException.Message.IndexOf ("something") != -1, "#B8");
Assert.IsNotNull (ex.InnerException.InnerException, "#B9");
//FIXME
/*
// There was an error reflecting type 'System.String'.
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.InnerException.GetType (), "#B10");
Assert.IsNotNull (ex.InnerException.InnerException.Message, "#B11");
Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (string).FullName) != -1, "#B12");
Assert.IsNotNull (ex.InnerException.InnerException.InnerException, "#B13");
// Value 'sometype' cannot be used for the XmlElementAttribute.DataType property.
// The datatype 'http://www.w3.org/2001/XMLSchema:sometype' is missing.
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.InnerException.InnerException.GetType (), "#B14");
Assert.IsNotNull (ex.InnerException.InnerException.InnerException.Message, "#B15");
Assert.IsTrue (ex.InnerException.InnerException.InnerException.Message.IndexOf ("http://www.w3.org/2001/XMLSchema:sometype") != -1, "#B16");
Assert.IsNull (ex.InnerException.InnerException.InnerException.InnerException, "#B17");
*/
}
}
// test xmlRoot //////////////////////////////////////////////////////////
[Test]
public void TestSerializeXmlRootAttribute ()
{
// constructor override & element name
XmlRootAttribute root = new XmlRootAttribute ();
root.ElementName = "renamed";
SimpleClassWithXmlAttributes simpleWithAttributes = new SimpleClassWithXmlAttributes ();
Serialize (simpleWithAttributes, root);
Assert.AreEqual (Infoset ("<renamed xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
SimpleClass simple = null;
root.IsNullable = false;
try {
Serialize (simple, root);
Assert.Fail ("Cannot serialize null object if XmlRoot's IsNullable == false");
} catch (NullReferenceException) {
}
root.IsNullable = true;
try {
Serialize (simple, root);
Assert.Fail ("Cannot serialize null object if XmlRoot's IsNullable == true");
} catch (NullReferenceException) {
}
simple = new SimpleClass ();
root.ElementName = null;
root.Namespace = "some.urn";
Serialize (simple, root);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns='some.urn' />"), WriterText);
}
[Test]
public void TestSerializeXmlRootAttributeOnMember ()
{
// nested root
XmlAttributeOverrides overrides = new XmlAttributeOverrides ();
XmlAttributes childAttr = new XmlAttributes ();
childAttr.XmlRoot = new XmlRootAttribute ("simple");
overrides.Add (typeof (SimpleClass), childAttr);
XmlAttributes attr = new XmlAttributes ();
attr.XmlRoot = new XmlRootAttribute ("simple");
overrides.Add (typeof (ClassArrayContainer), attr);
ClassArrayContainer container = new ClassArrayContainer ();
container.items = new SimpleClass[1];
container.items[0] = new SimpleClass ();
Serialize (container, overrides);
Assert.AreEqual (Infoset ("<simple xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' ><items><SimpleClass /></items></simple>"), WriterText);
// FIXME test data type
}
// test XmlAttribute /////////////////////////////////////////////////////
[Test]
public void TestSerializeXmlAttributeAttribute ()
{
// null
XmlAttributeOverrides overrides = new XmlAttributeOverrides ();
XmlAttributes attr = new XmlAttributes ();
attr.XmlAttribute = new XmlAttributeAttribute ();
overrides.Add (typeof (SimpleClass), "something", attr);
SimpleClass simple = new SimpleClass (); ;
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#1");
// regular
simple.something = "hello";
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' something='hello' />"), WriterText, "#2");
// AttributeName
attr.XmlAttribute.AttributeName = "somethingelse";
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' somethingelse='hello' />"), WriterText, "#3");
// Type
// FIXME this should work, shouldnt it?
// attr.XmlAttribute.Type = typeof(string);
// Serialize(simple, overrides);
// Assert(WriterText.EndsWith(" something='hello' />"));
// Namespace
attr.XmlAttribute.Namespace = "some:urn";
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' d1p1:somethingelse='hello' xmlns:d1p1='some:urn' />"), WriterText, "#4");
// FIXME DataType
// FIXME XmlSchemaForm Form
// FIXME write XmlQualifiedName as attribute
}
// test XmlElement ///////////////////////////////////////////////////////
[Test]
public void TestSerializeXmlElementAttribute ()
{
XmlAttributeOverrides overrides = new XmlAttributeOverrides ();
XmlAttributes attr = new XmlAttributes ();
XmlElementAttribute element = new XmlElementAttribute ();
attr.XmlElements.Add (element);
overrides.Add (typeof (SimpleClass), "something", attr);
// null
SimpleClass simple = new SimpleClass (); ;
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#1");
// not null
simple.something = "hello";
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>hello</something></SimpleClass>"), WriterText, "#2");
//ElementName
element.ElementName = "saying";
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><saying>hello</saying></SimpleClass>"), WriterText, "#3");
//IsNullable
element.IsNullable = false;
simple.something = null;
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#4");
element.IsNullable = true;
simple.something = null;
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><saying xsi:nil='true' /></SimpleClass>"), WriterText, "#5");
//Namespace
element.ElementName = null;
element.IsNullable = false;
element.Namespace = "some:urn";
simple.something = "hello";
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something xmlns='some:urn'>hello</something></SimpleClass>"), WriterText, "#6");
//FIXME DataType
//FIXME Form
//FIXME Type
}
// test XmlElementAttribute with arrays and collections //////////////////
[Test]
public void TestSerializeCollectionWithXmlElementAttribute ()
{
// the rule is:
// if no type is specified or the specified type
// matches the contents of the collection,
// serialize each element in an element named after the member.
// if the type does not match, or matches the collection itself,
// create a base wrapping element for the member, and then
// wrap each collection item in its own wrapping element based on type.
XmlAttributeOverrides overrides = new XmlAttributeOverrides ();
XmlAttributes attr = new XmlAttributes ();
XmlElementAttribute element = new XmlElementAttribute ();
attr.XmlElements.Add (element);
overrides.Add (typeof (StringCollectionContainer), "Messages", attr);
// empty collection & no type info in XmlElementAttribute
StringCollectionContainer container = new StringCollectionContainer ();
Serialize (container, overrides);
Assert.AreEqual (Infoset ("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#1");
// non-empty collection & no type info in XmlElementAttribute
container.Messages.Add ("hello");
Serialize (container, overrides);
Assert.AreEqual (Infoset ("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><Messages>hello</Messages></StringCollectionContainer>"), WriterText, "#2");
// non-empty collection & only type info in XmlElementAttribute
element.Type = typeof (StringCollection);
Serialize (container, overrides);
Assert.AreEqual (Infoset ("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><Messages><string>hello</string></Messages></StringCollectionContainer>"), WriterText, "#3");
// non-empty collection & only type info in XmlElementAttribute
element.Type = typeof (string);
Serialize (container, overrides);
Assert.AreEqual (Infoset ("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><Messages>hello</Messages></StringCollectionContainer>"), WriterText, "#4");
// two elements
container.Messages.Add ("goodbye");
element.Type = null;
Serialize (container, overrides);
Assert.AreEqual (Infoset ("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><Messages>hello</Messages><Messages>goodbye</Messages></StringCollectionContainer>"), WriterText, "#5");
}
// test DefaultValue /////////////////////////////////////////////////////
[Test]
public void TestSerializeDefaultValueAttribute ()
{
XmlAttributeOverrides overrides = new XmlAttributeOverrides ();
XmlAttributes attr = new XmlAttributes ();
string defaultValueInstance = "nothing";
attr.XmlDefaultValue = defaultValueInstance;
overrides.Add (typeof (SimpleClass), "something", attr);
// use the default
SimpleClass simple = new SimpleClass ();
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#A1");
// same value as default
simple.something = defaultValueInstance;
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#A2");
// some other value
simple.something = "hello";
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>hello</something></SimpleClass>"), WriterText, "#A3");
overrides = new XmlAttributeOverrides ();
attr = new XmlAttributes ();
attr.XmlAttribute = new XmlAttributeAttribute ();
attr.XmlDefaultValue = defaultValueInstance;
overrides.Add (typeof (SimpleClass), "something", attr);
// use the default
simple = new SimpleClass ();
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#B1");
// same value as default
simple.something = defaultValueInstance;
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#B2");
// some other value
simple.something = "hello";
Serialize (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass something='hello' xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#B3");
overrides = new XmlAttributeOverrides ();
attr = new XmlAttributes ();
attr.XmlAttribute = new XmlAttributeAttribute ("flagenc");
overrides.Add (typeof (TestDefault), "flagencoded", attr);
// use the default
TestDefault testDefault = new TestDefault ();
Serialize (testDefault);
Assert.AreEqual (Infoset ("<testDefault xmlns='urn:myNS' xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#C1");
// use the default with overrides
Serialize (testDefault, overrides);
Assert.AreEqual (Infoset ("<testDefault flagenc='e1 e4' xmlns='urn:myNS' xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#C2");
overrides = new XmlAttributeOverrides ();
attr = new XmlAttributes ();
attr.XmlAttribute = new XmlAttributeAttribute ("flagenc");
attr.XmlDefaultValue = (FlagEnum_Encoded.e1 | FlagEnum_Encoded.e4); // add default again
overrides.Add (typeof (TestDefault), "flagencoded", attr);
// use the default with overrides
Serialize (testDefault, overrides);
Assert.AreEqual (Infoset ("<testDefault xmlns='urn:myNS' xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#C3");
// use the default with overrides and default namspace
Serialize (testDefault, overrides, AnotherNamespace);
Assert.AreEqual (Infoset ("<testDefault xmlns='urn:myNS' xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#C4");
// non-default values
testDefault.strDefault = "Some Text";
testDefault.boolT = false;
testDefault.boolF = true;
testDefault.decimalval = 20m;
testDefault.flag = FlagEnum.e2;
testDefault.flagencoded = FlagEnum_Encoded.e2 | FlagEnum_Encoded.e1;
Serialize (testDefault);
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<testDefault xmlns='urn:myNS' xmlns:xsd='{0}' xmlns:xsi='{1}'>" +
" <strDefault>Some Text</strDefault>" +
" <boolT>false</boolT>" +
" <boolF>true</boolF>" +
" <decimalval>20</decimalval>" +
" <flag>two</flag>" +
" <flagencoded>e1 e2</flagencoded>" +
"</testDefault>", XmlSchema.Namespace, XmlSchema.InstanceNamespace)),
WriterText, "#C5");
Serialize (testDefault, overrides);
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<testDefault flagenc='e1 e2' xmlns='urn:myNS' xmlns:xsd='{0}' xmlns:xsi='{1}'>" +
" <strDefault>Some Text</strDefault>" +
" <boolT>false</boolT>" +
" <boolF>true</boolF>" +
" <decimalval>20</decimalval>" +
" <flag>two</flag>" +
"</testDefault>", XmlSchema.Namespace, XmlSchema.InstanceNamespace)),
WriterText, "#C6");
Serialize (testDefault, overrides, AnotherNamespace);
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<testDefault flagenc='e1 e2' xmlns='urn:myNS' xmlns:xsd='{0}' xmlns:xsi='{1}'>" +
" <strDefault>Some Text</strDefault>" +
" <boolT>false</boolT>" +
" <boolF>true</boolF>" +
" <decimalval>20</decimalval>" +
" <flag>two</flag>" +
"</testDefault>", XmlSchema.Namespace, XmlSchema.InstanceNamespace)),
WriterText, "#C7");
attr = new XmlAttributes ();
XmlTypeAttribute xmlType = new XmlTypeAttribute ("flagenum");
xmlType.Namespace = "yetanother:urn";
attr.XmlType = xmlType;
overrides.Add (typeof (FlagEnum_Encoded), attr);
Serialize (testDefault, overrides, AnotherNamespace);
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<testDefault flagenc='e1 e2' xmlns='urn:myNS' xmlns:xsd='{0}' xmlns:xsi='{1}'>" +
" <strDefault>Some Text</strDefault>" +
" <boolT>false</boolT>" +
" <boolF>true</boolF>" +
" <decimalval>20</decimalval>" +
" <flag>two</flag>" +
"</testDefault>", XmlSchema.Namespace, XmlSchema.InstanceNamespace)),
WriterText, "#C8");
attr = new XmlAttributes ();
attr.XmlType = new XmlTypeAttribute ("testDefault");
overrides.Add (typeof (TestDefault), attr);
Serialize (testDefault, overrides, AnotherNamespace);
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<testDefault flagenc='e1 e2' xmlns='{2}' xmlns:xsd='{0}' xmlns:xsi='{1}'>" +
" <strDefault>Some Text</strDefault>" +
" <boolT>false</boolT>" +
" <boolF>true</boolF>" +
" <decimalval>20</decimalval>" +
" <flag>two</flag>" +
"</testDefault>", XmlSchema.Namespace, XmlSchema.InstanceNamespace,
AnotherNamespace)), WriterText, "#C9");
}
[Test]
[Category ("NotWorking")] // SerializationCodeGenerator outputs wrong xsi:type for flagencoded in #C1
public void TestSerializeDefaultValueAttribute_Encoded ()
{
SoapAttributeOverrides overrides = new SoapAttributeOverrides ();
SoapAttributes attr = new SoapAttributes ();
attr.SoapAttribute = new SoapAttributeAttribute ();
string defaultValueInstance = "nothing";
attr.SoapDefaultValue = defaultValueInstance;
overrides.Add (typeof (SimpleClass), "something", attr);
// use the default
SimpleClass simple = new SimpleClass ();
SerializeEncoded (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass id='id1' xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#A1");
// same value as default
simple.something = defaultValueInstance;
SerializeEncoded (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass id='id1' xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#A2");
// some other value
simple.something = "hello";
SerializeEncoded (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass id='id1' something='hello' xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#A3");
attr.SoapAttribute = null;
attr.SoapElement = new SoapElementAttribute ();
// use the default
simple = new SimpleClass ();
SerializeEncoded (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass id='id1' xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText, "#B1");
// same value as default
simple.something = defaultValueInstance;
SerializeEncoded (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass id='id1' xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something xsi:type='xsd:string'>nothing</something></SimpleClass>"), WriterText, "#B2");
// some other value
simple.something = "hello";
SerializeEncoded (simple, overrides);
Assert.AreEqual (Infoset ("<SimpleClass id='id1' xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something xsi:type='xsd:string'>hello</something></SimpleClass>"), WriterText, "#B3");
overrides = new SoapAttributeOverrides ();
attr = new SoapAttributes ();
attr.SoapElement = new SoapElementAttribute ("flagenc");
overrides.Add (typeof (TestDefault), "flagencoded", attr);
// use the default (from MS KB325691)
TestDefault testDefault = new TestDefault ();
SerializeEncoded (testDefault);
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<q1:testDefault id='id1' xmlns:q1='urn:myNS' xmlns:xsd='{0}' xmlns:xsi='{1}'>" +
" <strDefault xsi:type='xsd:string'>Default Value</strDefault>" +
" <boolT xsi:type='xsd:boolean'>true</boolT>" +
" <boolF xsi:type='xsd:boolean'>false</boolF>" +
" <decimalval xsi:type='xsd:decimal'>10</decimalval>" +
" <flag xsi:type='FlagEnum'>e1 e4</flag>" +
" <flagencoded xsi:type='flagenum'>one four</flagencoded>" +
"</q1:testDefault>", XmlSchema.Namespace, XmlSchema.InstanceNamespace)),
WriterText, "#C1");
SerializeEncoded (testDefault, overrides);
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<q1:testDefault id='id1' xmlns:q1='urn:myNS' xmlns:xsd='{0}' xmlns:xsi='{1}'>" +
" <strDefault xsi:type='xsd:string'>Default Value</strDefault>" +
" <boolT xsi:type='xsd:boolean'>true</boolT>" +
" <boolF xsi:type='xsd:boolean'>false</boolF>" +
" <decimalval xsi:type='xsd:decimal'>10</decimalval>" +
" <flag xsi:type='FlagEnum'>e1 e4</flag>" +
" <flagenc xsi:type='flagenum'>one four</flagenc>" +
"</q1:testDefault>", XmlSchema.Namespace, XmlSchema.InstanceNamespace)),
WriterText, "#C2");
SerializeEncoded (testDefault, overrides, AnotherNamespace);
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<q1:testDefault id='id1' xmlns:q1='urn:myNS' xmlns:xsd='{0}' xmlns:xsi='{1}'>" +
" <strDefault xsi:type='xsd:string'>Default Value</strDefault>" +
" <boolT xsi:type='xsd:boolean'>true</boolT>" +
" <boolF xsi:type='xsd:boolean'>false</boolF>" +
" <decimalval xsi:type='xsd:decimal'>10</decimalval>" +
" <flag xmlns:q2='{2}' xsi:type='q2:FlagEnum'>e1 e4</flag>" +
" <flagenc xmlns:q3='{2}' xsi:type='q3:flagenum'>one four</flagenc>" +
"</q1:testDefault>", XmlSchema.Namespace, XmlSchema.InstanceNamespace,
AnotherNamespace)), WriterText, "#C3");
// non-default values
testDefault.strDefault = "Some Text";
testDefault.boolT = false;
testDefault.boolF = true;
testDefault.decimalval = 20m;
testDefault.flag = FlagEnum.e2;
testDefault.flagencoded = FlagEnum_Encoded.e2 | FlagEnum_Encoded.e1;
SerializeEncoded (testDefault);
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<q1:testDefault id='id1' xmlns:q1='urn:myNS' xmlns:xsd='{0}' xmlns:xsi='{1}'>" +
" <strDefault xsi:type='xsd:string'>Some Text</strDefault>" +
" <boolT xsi:type='xsd:boolean'>false</boolT>" +
" <boolF xsi:type='xsd:boolean'>true</boolF>" +
" <decimalval xsi:type='xsd:decimal'>20</decimalval>" +
" <flag xsi:type='FlagEnum'>e2</flag>" +
" <flagencoded xsi:type='flagenum'>one two</flagencoded>" +
"</q1:testDefault>", XmlSchema.Namespace, XmlSchema.InstanceNamespace)),
WriterText, "#C4");
SerializeEncoded (testDefault, overrides);
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<q1:testDefault id='id1' xmlns:q1='urn:myNS' xmlns:xsd='{0}' xmlns:xsi='{1}'>" +
" <strDefault xsi:type='xsd:string'>Some Text</strDefault>" +
" <boolT xsi:type='xsd:boolean'>false</boolT>" +
" <boolF xsi:type='xsd:boolean'>true</boolF>" +
" <decimalval xsi:type='xsd:decimal'>20</decimalval>" +
" <flag xsi:type='FlagEnum'>e2</flag>" +
" <flagenc xsi:type='flagenum'>one two</flagenc>" +
"</q1:testDefault>", XmlSchema.Namespace, XmlSchema.InstanceNamespace)),
WriterText, "#C5");
attr = new SoapAttributes ();
attr.SoapType = new SoapTypeAttribute ("flagenum", "yetanother:urn");
overrides.Add (typeof (FlagEnum_Encoded), attr);
SerializeEncoded (testDefault, overrides, AnotherNamespace);
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<q1:testDefault id='id1' xmlns:q1='urn:myNS' xmlns:xsd='{0}' xmlns:xsi='{1}'>" +
" <strDefault xsi:type='xsd:string'>Some Text</strDefault>" +
" <boolT xsi:type='xsd:boolean'>false</boolT>" +
" <boolF xsi:type='xsd:boolean'>true</boolF>" +
" <decimalval xsi:type='xsd:decimal'>20</decimalval>" +
" <flag xmlns:q2='{2}' xsi:type='q2:FlagEnum'>e2</flag>" +
" <flagenc xmlns:q3='yetanother:urn' xsi:type='q3:flagenum'>one two</flagenc>" +
"</q1:testDefault>", XmlSchema.Namespace, XmlSchema.InstanceNamespace,
AnotherNamespace)), WriterText, "#C6");
attr = new SoapAttributes ();
attr.SoapType = new SoapTypeAttribute ("testDefault");
overrides.Add (typeof (TestDefault), attr);
SerializeEncoded (testDefault, overrides, AnotherNamespace);
Assert.AreEqual (Infoset (string.Format (CultureInfo.InvariantCulture,
"<q1:testDefault id='id1' xmlns:q1='{2}' xmlns:xsd='{0}' xmlns:xsi='{1}'>" +
" <strDefault xsi:type='xsd:string'>Some Text</strDefault>" +
" <boolT xsi:type='xsd:boolean'>false</boolT>" +
" <boolF xsi:type='xsd:boolean'>true</boolF>" +
" <decimalval xsi:type='xsd:decimal'>20</decimalval>" +
" <flag xsi:type='q1:FlagEnum'>e2</flag>" +
" <flagenc xmlns:q2='yetanother:urn' xsi:type='q2:flagenum'>one two</flagenc>" +
"</q1:testDefault>", XmlSchema.Namespace, XmlSchema.InstanceNamespace,
AnotherNamespace)), WriterText, "#C7");
}
// test XmlEnum //////////////////////////////////////////////////////////
[Test]
public void TestSerializeXmlEnumAttribute ()
{
Serialize (XmlSchemaForm.Qualified);
Assert.AreEqual (Infoset ("<XmlSchemaForm>qualified</XmlSchemaForm>"), WriterText, "#1");
Serialize (XmlSchemaForm.Unqualified);
Assert.AreEqual (Infoset ("<XmlSchemaForm>unqualified</XmlSchemaForm>"), WriterText, "#2");
}
[Test]
public void TestSerializeXmlEnumAttribute_IgnoredValue ()
{
// technically XmlSchemaForm.None has an XmlIgnore attribute,
// but it is not being serialized as a member.
#if NET_2_0
try {
Serialize (XmlSchemaForm.None);
Assert.Fail ("#1");
} catch (InvalidOperationException ex) {
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
Assert.IsNotNull (ex.InnerException, "#3");
Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#4");
Assert.IsNotNull (ex.InnerException.Message, "#5");
Assert.IsTrue (ex.InnerException.Message.IndexOf ("'0'") != -1, "#6");
Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (XmlSchemaForm).FullName) != -1, "#7");
}
#else
Serialize (XmlSchemaForm.None);
Assert.AreEqual (Infoset ("<XmlSchemaForm>0</XmlSchemaForm>"), WriterText);
#endif
}
[Test]
public void TestSerializeXmlNodeArray ()
{
XmlDocument doc = new XmlDocument ();
Serialize (new XmlNode[] { doc.CreateAttribute ("at"), doc.CreateElement ("elem1"), doc.CreateElement ("elem2") }, typeof (object));
Assert.AreEqual (Infoset ("<anyType at=\"\"><elem1/><elem2/></anyType>"), WriterText);
}
[Test]
public void TestSerializeXmlNodeArray2 ()
{
XmlDocument doc = new XmlDocument ();
Serialize (new XmlNode[] { doc.CreateElement ("elem1"), doc.CreateElement ("elem2") }, typeof (XmlNode []));
Assert.AreEqual (Infoset (String.Format ("<ArrayOfXmlNode xmlns:xsd='{0}' xmlns:xsi='{1}'><XmlNode><elem1/></XmlNode><XmlNode><elem2/></XmlNode></ArrayOfXmlNode>", XmlSchema.Namespace, XmlSchema.InstanceNamespace)), WriterText);
}
[Test]
[ExpectedException (typeof (InvalidOperationException))]
[Category ("NotWorking")]
public void TestSerializeXmlNodeArrayIncludesAttribute ()
{
XmlDocument doc = new XmlDocument ();
Serialize (new XmlNode[] { doc.CreateAttribute ("at"), doc.CreateElement ("elem1"), doc.CreateElement ("elem2") }, typeof (XmlNode []));
}
[Test]
public void TestSerializeXmlElementArray ()
{
XmlDocument doc = new XmlDocument ();
Serialize (new XmlElement[] { doc.CreateElement ("elem1"), doc.CreateElement ("elem2") }, typeof (object));
Assert.AreEqual (Infoset ("<anyType><elem1/><elem2/></anyType>"), WriterText);
}
#if NET_2_0
[Test]
[ExpectedException (typeof (InvalidOperationException))] // List<XmlNode> is not supported
public void TestSerializeGenericListOfNode ()
{
XmlDocument doc = new XmlDocument ();
Serialize (new List<XmlNode> (new XmlNode [] { doc.CreateAttribute ("at"), doc.CreateElement ("elem1"), doc.CreateElement ("elem2") }), typeof (object));
Assert.AreEqual (Infoset ("<anyType at=\"\"><elem1/><elem2/></anyType>"), WriterText);
}
[Test]
[ExpectedException (typeof (InvalidOperationException))] // List<XmlElement> is not supported
public void TestSerializeGenericListOfElement ()
{
XmlDocument doc = new XmlDocument ();
Serialize (new List<XmlElement> (new XmlElement [] { doc.CreateElement ("elem1"), doc.CreateElement ("elem2") }), typeof (object));
Assert.AreEqual (Infoset ("<anyType><elem1/><elem2/></anyType>"), WriterText);
}
#endif
[Test]
public void TestSerializeXmlDocument ()
{
XmlDocument doc = new XmlDocument ();
doc.LoadXml (@"<?xml version=""1.0"" encoding=""utf-8"" ?><root/>");
Serialize (doc, typeof (XmlDocument));
Assert.AreEqual ("<?xml version='1.0' encoding='utf-16'?><root />",
sw.GetStringBuilder ().ToString ());
}
[Test]
public void TestSerializeXmlElement ()
{
XmlDocument doc = new XmlDocument ();
Serialize (doc.CreateElement ("elem"), typeof (XmlElement));
Assert.AreEqual (Infoset ("<elem/>"), WriterText);
}
[Test]
public void TestSerializeXmlElementSubclass ()
{
XmlDocument doc = new XmlDocument ();
Serialize (new MyElem (doc), typeof (XmlElement));
Assert.AreEqual (Infoset ("<myelem aa=\"1\"/>"), WriterText, "#1");
Serialize (new MyElem (doc), typeof (MyElem));
Assert.AreEqual (Infoset ("<myelem aa=\"1\"/>"), WriterText, "#2");
}
[Test]
public void TestSerializeXmlCDataSection ()
{
XmlDocument doc = new XmlDocument ();
CDataContainer c = new CDataContainer ();
c.cdata = doc.CreateCDataSection ("data section contents");
Serialize (c);
Assert.AreEqual (Infoset ("<CDataContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><cdata><![CDATA[data section contents]]></cdata></CDataContainer>"), WriterText);
}
[Test]
public void TestSerializeXmlNode ()
{
XmlDocument doc = new XmlDocument ();
NodeContainer c = new NodeContainer ();
c.node = doc.CreateTextNode ("text");
Serialize (c);
Assert.AreEqual (Infoset ("<NodeContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><node>text</node></NodeContainer>"), WriterText);
}
[Test]
public void TestSerializeChoice ()
{
Choices ch = new Choices ();
ch.MyChoice = "choice text";
ch.ItemType = ItemChoiceType.ChoiceZero;
Serialize (ch);
Assert.AreEqual (Infoset ("<Choices xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><ChoiceZero>choice text</ChoiceZero></Choices>"), WriterText, "#1");
ch.ItemType = ItemChoiceType.StrangeOne;
Serialize (ch);
Assert.AreEqual (Infoset ("<Choices xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><ChoiceOne>choice text</ChoiceOne></Choices>"), WriterText, "#2");
ch.ItemType = ItemChoiceType.ChoiceTwo;
Serialize (ch);
Assert.AreEqual (Infoset ("<Choices xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><ChoiceTwo>choice text</ChoiceTwo></Choices>"), WriterText, "#3");
}
[Test]
public void TestSerializeNamesWithSpaces ()
{
TestSpace ts = new TestSpace ();
ts.elem = 4;
ts.attr = 5;
Serialize (ts);
Assert.AreEqual (Infoset ("<Type_x0020_with_x0020_space xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' Attribute_x0020_with_x0020_space='5'><Element_x0020_with_x0020_space>4</Element_x0020_with_x0020_space></Type_x0020_with_x0020_space>"), WriterText);
}
[Test]
public void TestSerializeReadOnlyProps ()
{
ReadOnlyProperties ts = new ReadOnlyProperties ();
Serialize (ts);
Assert.AreEqual (Infoset ("<ReadOnlyProperties xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
}
[Test]
public void TestSerializeReadOnlyListProp ()
{
ReadOnlyListProperty ts = new ReadOnlyListProperty ();
Serialize (ts);
Assert.AreEqual (Infoset ("<ReadOnlyListProperty xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><StrList><string>listString1</string><string>listString2</string></StrList></ReadOnlyListProperty>"), WriterText);
}
[Test]
public void TestSerializeIList ()
{
clsPerson k = new clsPerson ();
k.EmailAccounts = new ArrayList ();
k.EmailAccounts.Add ("a");
k.EmailAccounts.Add ("b");
Serialize (k);
Assert.AreEqual (Infoset ("<clsPerson xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"><EmailAccounts><anyType xsi:type=\"xsd:string\">a</anyType><anyType xsi:type=\"xsd:string\">b</anyType></EmailAccounts></clsPerson>"), WriterText);
}
[Test]
public void TestSerializeArrayEnc ()
{
SoapReflectionImporter imp = new SoapReflectionImporter ();
XmlTypeMapping map = imp.ImportTypeMapping (typeof (ArrayClass));
XmlSerializer ser = new XmlSerializer (map);
StringWriter sw = new StringWriter ();
XmlTextWriter tw = new XmlTextWriter (sw);
tw.WriteStartElement ("aa");
ser.Serialize (tw, new ArrayClass ());
tw.WriteEndElement ();
}
[Test] // bug #76049
public void TestIncludeType ()
{
XmlReflectionImporter imp = new XmlReflectionImporter ();
XmlTypeMapping map = imp.ImportTypeMapping (typeof (object));
imp.IncludeType (typeof (TestSpace));
XmlSerializer ser = new XmlSerializer (map);
ser.Serialize (new StringWriter (), new TestSpace ());
}
[Test]
public void TestSerializeChoiceArray ()
{
CompositeValueType v = new CompositeValueType ();
v.Init ();
Serialize (v);
Assert.AreEqual (Infoset ("<?xml version=\"1.0\" encoding=\"utf-16\"?><CompositeValueType xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"><In>1</In><Es>2</Es></CompositeValueType>"), WriterText);
}
[Test]
public void TestArrayAttributeWithDataType ()
{
Serialize (new ArrayAttributeWithType ());
string res = "<ArrayAttributeWithType xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' ";
res += "at='a b' bin1='AQI= AQI=' bin2='AQI=' />";
Assert.AreEqual (Infoset (res), WriterText);
}
[Test]
public void TestSubclassElementType ()
{
SubclassTestContainer c = new SubclassTestContainer ();
c.data = new SubclassTestSub ();
Serialize (c);
string res = "<SubclassTestContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
res += "<a xsi:type=\"SubclassTestSub\"/></SubclassTestContainer>";
Assert.AreEqual (Infoset (res), WriterText);
}
[Test]
[ExpectedException (typeof (InvalidOperationException))]
public void TestArrayAttributeWithWrongDataType ()
{
Serialize (new ArrayAttributeWithWrongType ());
}
[Test]
[Category ("NotWorking")]
public void TestSerializePrimitiveTypesContainer ()
{
Serialize (new PrimitiveTypesContainer ());
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
#if NET_2_0
"<PrimitiveTypesContainer xmlns:xsi='{1}' xmlns:xsd='{0}' xmlns='some:urn'>" +
#else
"<PrimitiveTypesContainer xmlns:xsd='{0}' xmlns:xsi='{1}' xmlns='some:urn'>" +
#endif
"<Number>2004</Number>" +
"<Name>some name</Name>" +
"<Index>56</Index>" +
"<Password>8w8=</Password>" +
"<PathSeparatorCharacter>47</PathSeparatorCharacter>" +
"</PrimitiveTypesContainer>", XmlSchema.Namespace,
XmlSchema.InstanceNamespace), sw.ToString (), "#1");
SerializeEncoded (new PrimitiveTypesContainer ());
Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
"<?xml version='1.0' encoding='utf-16'?>" +
#if NET_2_0
"<q1:PrimitiveTypesContainer xmlns:xsi='{1}' xmlns:xsd='{0}' id='id1' xmlns:q1='{2}'>" +
#else
"<q1:PrimitiveTypesContainer xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' xmlns:q1='{2}'>" +
#endif
"<Number xsi:type='xsd:int'>2004</Number>" +
"<Name xsi:type='xsd:string'>some name</Name>" +
"<Index xsi:type='xsd:unsignedByte'>56</Index>" +
"<Password xsi:type='xsd:base64Binary'>8w8=</Password>" +
"<PathSeparatorCharacter xmlns:q2='{3}' xsi:type='q2:char'>47</PathSeparatorCharacter>" +
"</q1:PrimitiveTypesContainer>", XmlSchema.Namespace,
XmlSchema.InstanceNamespace, AnotherNamespace, WsdlTypesNamespace),
sw.ToString (), "#2");
}
[Test]
public void TestSchemaForm ()
{
TestSchemaForm1 t1 = new TestSchemaForm1 ();
t1.p1 = new PrintTypeResponse ();
t1.p1.Init ();
t1.p2 = new PrintTypeResponse ();
t1.p2.Init ();
TestSchemaForm2 t2 = new TestSchemaForm2 ();
t2.p1 = new PrintTypeResponse ();
t2.p1.Init ();
t2.p2 = new PrintTypeResponse ();
t2.p2.Init ();
Serialize (t1);
string res = "";
res += "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
res += "<TestSchemaForm1 xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">";
res += " <p1>";
res += " <result>";
res += " <data>data1</data>";
res += " </result>";
res += " <intern xmlns=\"urn:responseTypes\">";
res += " <result xmlns=\"\">";
res += " <data>data2</data>";
res += " </result>";
res += " </intern>";
res += " </p1>";
res += " <p2 xmlns=\"urn:oo\">";
res += " <result xmlns=\"\">";
res += " <data>data1</data>";
res += " </result>";
res += " <intern xmlns=\"urn:responseTypes\">";
res += " <result xmlns=\"\">";
res += " <data>data2</data>";
res += " </result>";
res += " </intern>";
res += " </p2>";
res += "</TestSchemaForm1>";
Assert.AreEqual (Infoset (res), WriterText);
Serialize (t2);
res = "";
res += "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
res += "<TestSchemaForm2 xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">";
res += " <p1 xmlns=\"urn:testForm\">";
res += " <result xmlns=\"\">";
res += " <data>data1</data>";
res += " </result>";
res += " <intern xmlns=\"urn:responseTypes\">";
res += " <result xmlns=\"\">";
res += " <data>data2</data>";
res += " </result>";
res += " </intern>";
res += " </p1>";
res += " <p2 xmlns=\"urn:oo\">";
res += " <result xmlns=\"\">";
res += " <data>data1</data>";
res += " </result>";
res += " <intern xmlns=\"urn:responseTypes\">";
res += " <result xmlns=\"\">";
res += " <data>data2</data>";
res += " </result>";
res += " </intern>";
res += " </p2>";
res += "</TestSchemaForm2>";
Assert.AreEqual (Infoset (res), WriterText);
XmlReflectionImporter imp = new XmlReflectionImporter ();
XmlTypeMapping map = imp.ImportTypeMapping (typeof (TestSchemaForm1), "urn:extra");
Serialize (t1, map);
res = "";
res += "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
res += "<TestSchemaForm1 xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"urn:extra\">";
res += " <p1>";
res += " <result xmlns=\"\">";
res += " <data>data1</data>";
res += " </result>";
res += " <intern xmlns=\"urn:responseTypes\">";
res += " <result xmlns=\"\">";
res += " <data>data2</data>";
res += " </result>";
res += " </intern>";
res += " </p1>";
res += " <p2 xmlns=\"urn:oo\">";
res += " <result xmlns=\"\">";
res += " <data>data1</data>";
res += " </result>";
res += " <intern xmlns=\"urn:responseTypes\">";
res += " <result xmlns=\"\">";
res += " <data>data2</data>";
res += " </result>";
res += " </intern>";
res += " </p2>";
res += "</TestSchemaForm1>";
Assert.AreEqual (Infoset (res), WriterText);
imp = new XmlReflectionImporter ();
map = imp.ImportTypeMapping (typeof (TestSchemaForm2), "urn:extra");
Serialize (t2, map);
res = "";
res += "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
res += "<TestSchemaForm2 xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"urn:extra\">";
res += " <p1 xmlns=\"urn:testForm\">";
res += " <result xmlns=\"\">";
res += " <data>data1</data>";
res += " </result>";
res += " <intern xmlns=\"urn:responseTypes\">";
res += " <result xmlns=\"\">";
res += " <data>data2</data>";
res += " </result>";
res += " </intern>";
res += " </p1>";
res += " <p2 xmlns=\"urn:oo\">";
res += " <result xmlns=\"\">";
res += " <data>data1</data>";
res += " </result>";
res += " <intern xmlns=\"urn:responseTypes\">";
res += " <result xmlns=\"\">";
res += " <data>data2</data>";
res += " </result>";
res += " </intern>";
res += " </p2>";
res += "</TestSchemaForm2>";
Assert.AreEqual (Infoset (res), WriterText);
}
[Test] // bug #78536
public void CDataTextNodes ()
{
XmlSerializer ser = new XmlSerializer (typeof (CDataTextNodesType));
ser.UnknownNode += new XmlNodeEventHandler (CDataTextNodes_BadNode);
string xml = @"<CDataTextNodesType>
<foo><![CDATA[
(?<filename>^([A-Z]:)?[^\(]+)\((?<line>\d+),(?<column>\d+)\):
\s((?<warning>warning)|(?<error>error))\s[^:]+:(?<message>.+$)|
(?<error>(fatal\s)?error)[^:]+:(?<message>.+$)
]]></foo>
</CDataTextNodesType>";
ser.Deserialize (new XmlTextReader (xml, XmlNodeType.Document, null));
}
#if !MOBILE
[Test]
public void GenerateSerializerGenerics ()
{
XmlReflectionImporter imp = new XmlReflectionImporter ();
Type type = typeof (List<int>);
XmlSerializer.GenerateSerializer (
new Type [] {type},
new XmlTypeMapping [] {imp.ImportTypeMapping (type)});
}
#endif
[Test]
public void Nullable ()
{
XmlSerializer ser = new XmlSerializer (typeof (int?));
int? nullableType = 5;
sw = new StringWriter ();
xtw = new XmlTextWriter (sw);
ser.Serialize (xtw, nullableType);
xtw.Close ();
string expected = "<?xml version=\"1.0\" encoding=\"utf-16\"?><int>5</int>";
Assert.AreEqual (Infoset (expected), WriterText);
int? i = (int?) ser.Deserialize (new StringReader (sw.ToString ()));
Assert.AreEqual (5, i);
}
[Test]
public void NullableEnums ()
{
WithNulls w = new WithNulls ();
XmlSerializer ser = new XmlSerializer (typeof(WithNulls));
StringWriter tw = new StringWriter ();
ser.Serialize (tw, w);
string expected = "<?xml version='1.0' encoding='utf-16'?>" +
"<WithNulls xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xsd='http://www.w3.org/2001/XMLSchema'>" +
"<nint xsi:nil='true' />" +
"<nenum xsi:nil='true' />" +
"<ndate xsi:nil='true' />" +
"</WithNulls>";
Assert.AreEqual (Infoset (expected), Infoset (tw.ToString ()));
StringReader sr = new StringReader (tw.ToString ());
w = (WithNulls) ser.Deserialize (sr);
Assert.IsFalse (w.nint.HasValue);
Assert.IsFalse (w.nenum.HasValue);
Assert.IsFalse (w.ndate.HasValue);
DateTime t = new DateTime (2008,4,1);
w.nint = 4;
w.ndate = t;
w.nenum = TestEnumWithNulls.bb;
tw = new StringWriter ();
ser.Serialize (tw, w);
expected = "<?xml version='1.0' encoding='utf-16'?>" +
"<WithNulls xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xsd='http://www.w3.org/2001/XMLSchema'>" +
"<nint>4</nint>" +
"<nenum>bb</nenum>" +
"<ndate>2008-04-01T00:00:00</ndate>" +
"</WithNulls>";
Assert.AreEqual (Infoset (expected), Infoset (tw.ToString ()));
sr = new StringReader (tw.ToString ());
w = (WithNulls) ser.Deserialize (sr);
Assert.IsTrue (w.nint.HasValue);
Assert.IsTrue (w.nenum.HasValue);
Assert.IsTrue (w.ndate.HasValue);
Assert.AreEqual (4, w.nint.Value);
Assert.AreEqual (TestEnumWithNulls.bb, w.nenum.Value);
Assert.AreEqual (t, w.ndate.Value);
}
[Test]
public void SerializeBase64Binary()
{
XmlSerializer ser = new XmlSerializer (typeof (Base64Binary));
sw = new StringWriter ();
XmlTextWriter xtw = new XmlTextWriter (sw);
ser.Serialize (xtw, new Base64Binary ());
xtw.Close ();
string expected = @"<?xml version=""1.0"" encoding=""utf-16""?><Base64Binary xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" Data=""AQID"" />";
Assert.AreEqual (Infoset (expected), WriterText);
Base64Binary h = (Base64Binary) ser.Deserialize (new StringReader (sw.ToString ()));
Assert.AreEqual (new byte [] {1, 2, 3}, h.Data);
}
[Test] // bug #79989, #79990
public void SerializeHexBinary ()
{
XmlSerializer ser = new XmlSerializer (typeof (HexBinary));
sw = new StringWriter ();
XmlTextWriter xtw = new XmlTextWriter (sw);
ser.Serialize (xtw, new HexBinary ());
xtw.Close ();
string expected = @"<?xml version=""1.0"" encoding=""utf-16""?><HexBinary xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" Data=""010203"" />";
Assert.AreEqual (Infoset (expected), WriterText);
HexBinary h = (HexBinary) ser.Deserialize (new StringReader (sw.ToString ()));
Assert.AreEqual (new byte[] { 1, 2, 3 }, h.Data);
}
[Test]
[ExpectedException (typeof (InvalidOperationException))]
public void XmlArrayAttributeOnInt ()
{
new XmlSerializer (typeof (XmlArrayOnInt));
}
[Test]
[ExpectedException (typeof (InvalidOperationException))]
public void XmlArrayAttributeUnqualifiedWithNamespace ()
{
new XmlSerializer (typeof (XmlArrayUnqualifiedWithNamespace));
}
[Test]
[ExpectedException (typeof (InvalidOperationException))]
public void XmlArrayItemAttributeUnqualifiedWithNamespace ()
{
new XmlSerializer (typeof (XmlArrayItemUnqualifiedWithNamespace));
}
[Test] // bug #78042
public void XmlArrayAttributeOnArray ()
{
XmlSerializer ser = new XmlSerializer (typeof (XmlArrayOnArray));
sw = new StringWriter ();
XmlTextWriter xtw = new XmlTextWriter (sw);
ser.Serialize (xtw, new XmlArrayOnArray ());
xtw.Close ();
string expected = @"<?xml version=""1.0"" encoding=""utf-16""?><XmlArrayOnArray xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""urn:foo""><Sane xmlns=""""><string xmlns=""urn:foo"">foo</string><string xmlns=""urn:foo"">bar</string></Sane><Mids xmlns=""""><ArrayItemInXmlArray xmlns=""urn:foo""><Whee xmlns=""""><string xmlns=""urn:gyabo"">foo</string><string xmlns=""urn:gyabo"">bar</string></Whee></ArrayItemInXmlArray></Mids></XmlArrayOnArray>";
Assert.AreEqual (Infoset (expected), WriterText);
}
[Test]
public void XmlArrayAttributeOnCollection ()
{
XmlSerializer ser = new XmlSerializer (typeof (XmlArrayOnArrayList));
XmlArrayOnArrayList inst = new XmlArrayOnArrayList ();
inst.Sane.Add ("abc");
inst.Sane.Add (1);
sw = new StringWriter ();
XmlTextWriter xtw = new XmlTextWriter (sw);
ser.Serialize (xtw, inst);
xtw.Close ();
string expected = @"<?xml version=""1.0"" encoding=""utf-16""?><XmlArrayOnArrayList xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""urn:foo""><Sane xmlns=""""><anyType xsi:type=""xsd:string"" xmlns=""urn:foo"">abc</anyType><anyType xsi:type=""xsd:int"" xmlns=""urn:foo"">1</anyType></Sane></XmlArrayOnArrayList>";
Assert.AreEqual (Infoset (expected), WriterText);
}
[Test] // bug #338705
public void SerializeTimeSpan ()
{
// TimeSpan itself is not for duration. Hence it is just regarded as one of custom types.
XmlSerializer ser = new XmlSerializer (typeof (TimeSpan));
ser.Serialize (TextWriter.Null, TimeSpan.Zero);
}
[Test]
public void SerializeDurationToString ()
{
XmlSerializer ser = new XmlSerializer (typeof (TimeSpanContainer1));
ser.Serialize (TextWriter.Null, new TimeSpanContainer1 ());
}
[Test]
[ExpectedException (typeof (InvalidOperationException))]
public void SerializeDurationToTimeSpan ()
{
XmlSerializer ser = new XmlSerializer (typeof (TimeSpanContainer2));
ser.Serialize (TextWriter.Null, new TimeSpanContainer2 ());
}
[Test]
[ExpectedException (typeof (InvalidOperationException))]
public void SerializeInvalidDataType ()
{
XmlSerializer ser = new XmlSerializer (typeof (InvalidTypeContainer));
ser.Serialize (TextWriter.Null, new InvalidTypeContainer ());
}
[Test]
#if !NET_2_0
[ExpectedException (typeof (ApplicationException))]
#endif
public void SerializeErrorneousIXmlSerializable ()
{
Serialize (new ErrorneousGetSchema ());
Assert.AreEqual ("<:ErrorneousGetSchema></>", Infoset (sw.ToString ()));
}
#if NET_2_0
public void DateTimeRoundtrip ()
{
// bug #337729
XmlSerializer ser = new XmlSerializer (typeof (DateTime));
StringWriter sw = new StringWriter ();
ser.Serialize (sw, DateTime.UtcNow);
DateTime d = (DateTime) ser.Deserialize (new StringReader (sw.ToString ()));
Assert.AreEqual (DateTimeKind.Utc, d.Kind);
}
#endif
[Test]
public void SupportIXmlSerializableImplicitlyConvertible ()
{
XmlAttributes attrs = new XmlAttributes ();
XmlElementAttribute attr = new XmlElementAttribute ();
attr.ElementName = "XmlSerializable";
attr.Type = typeof (XmlSerializableImplicitConvertible.XmlSerializable);
attrs.XmlElements.Add (attr);
XmlAttributeOverrides attrOverrides = new
XmlAttributeOverrides ();
attrOverrides.Add (typeof (XmlSerializableImplicitConvertible), "B", attrs);
XmlSerializableImplicitConvertible x = new XmlSerializableImplicitConvertible ();
new XmlSerializer (typeof (XmlSerializableImplicitConvertible), attrOverrides).Serialize (TextWriter.Null, x);
}
[Test] // bug #566370
public void SerializeEnumWithCSharpKeyword ()
{
var ser = new XmlSerializer (typeof (DoxCompoundKind));
for (int i = 0; i < 100; i++) // test serialization code generator
ser.Serialize (Console.Out, DoxCompoundKind.@class);
}
public enum DoxCompoundKind
{
[XmlEnum("class")]
@class,
[XmlEnum("struct")]
@struct,
union,
[XmlEnum("interface")]
@interface,
protocol,
category,
exception,
file,
[XmlEnum("namespace")]
@namespace,
group,
page,
example,
dir
}
#region GenericsSeralizationTests
#if NET_2_0
[Test]
public void TestSerializeGenSimpleClassString ()
{
GenSimpleClass<string> simple = new GenSimpleClass<string> ();
Serialize (simple);
Assert.AreEqual (Infoset ("<GenSimpleClassOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
simple.something = "hello";
Serialize (simple);
Assert.AreEqual (Infoset ("<GenSimpleClassOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>hello</something></GenSimpleClassOfString>"), WriterText);
}
[Test]
public void TestSerializeGenSimpleClassBool ()
{
GenSimpleClass<bool> simple = new GenSimpleClass<bool> ();
Serialize (simple);
Assert.AreEqual (Infoset ("<GenSimpleClassOfBoolean xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>false</something></GenSimpleClassOfBoolean>"), WriterText);
simple.something = true;
Serialize (simple);
Assert.AreEqual (Infoset ("<GenSimpleClassOfBoolean xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>true</something></GenSimpleClassOfBoolean>"), WriterText);
}
[Test]
public void TestSerializeGenSimpleStructInt ()
{
GenSimpleStruct<int> simple = new GenSimpleStruct<int> (0);
Serialize (simple);
Assert.AreEqual (Infoset ("<GenSimpleStructOfInt32 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>0</something></GenSimpleStructOfInt32>"), WriterText);
simple.something = 123;
Serialize (simple);
Assert.AreEqual (Infoset ("<GenSimpleStructOfInt32 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>123</something></GenSimpleStructOfInt32>"), WriterText);
}
[Test]
public void TestSerializeGenListClassString ()
{
GenListClass<string> genlist = new GenListClass<string> ();
Serialize (genlist);
Assert.AreEqual (Infoset ("<GenListClassOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist></somelist></GenListClassOfString>"), WriterText);
genlist.somelist.Add ("Value1");
genlist.somelist.Add ("Value2");
Serialize (genlist);
Assert.AreEqual (Infoset ("<GenListClassOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist><string>Value1</string><string>Value2</string></somelist></GenListClassOfString>"), WriterText);
}
[Test]
public void TestSerializeGenListClassFloat ()
{
GenListClass<float> genlist = new GenListClass<float> ();
Serialize (genlist);
Assert.AreEqual (Infoset ("<GenListClassOfSingle xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist></somelist></GenListClassOfSingle>"), WriterText);
genlist.somelist.Add (1);
genlist.somelist.Add (2.2F);
Serialize (genlist);
Assert.AreEqual (Infoset ("<GenListClassOfSingle xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist><float>1</float><float>2.2</float></somelist></GenListClassOfSingle>"), WriterText);
}
[Test]
public void TestSerializeGenListClassList ()
{
GenListClass<GenListClass<int>> genlist = new GenListClass<GenListClass<int>> ();
Serialize (genlist);
Assert.AreEqual (Infoset ("<GenListClassOfGenListClassOfInt32 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist></somelist></GenListClassOfGenListClassOfInt32>"), WriterText);
GenListClass<int> inlist1 = new GenListClass<int> ();
inlist1.somelist.Add (1);
inlist1.somelist.Add (2);
GenListClass<int> inlist2 = new GenListClass<int> ();
inlist2.somelist.Add (10);
inlist2.somelist.Add (20);
genlist.somelist.Add (inlist1);
genlist.somelist.Add (inlist2);
Serialize (genlist);
Assert.AreEqual (Infoset ("<GenListClassOfGenListClassOfInt32 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist><GenListClassOfInt32><somelist><int>1</int><int>2</int></somelist></GenListClassOfInt32><GenListClassOfInt32><somelist><int>10</int><int>20</int></somelist></GenListClassOfInt32></somelist></GenListClassOfGenListClassOfInt32>"), WriterText);
}
[Test]
public void TestSerializeGenListClassArray ()
{
GenListClass<GenArrayClass<char>> genlist = new GenListClass<GenArrayClass<char>> ();
Serialize (genlist);
Assert.AreEqual (Infoset ("<GenListClassOfGenArrayClassOfChar xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist></somelist></GenListClassOfGenArrayClassOfChar>"), WriterText);
GenArrayClass<char> genarr1 = new GenArrayClass<char> ();
genarr1.arr[0] = 'a';
genarr1.arr[1] = 'b';
genlist.somelist.Add (genarr1);
GenArrayClass<char> genarr2 = new GenArrayClass<char> ();
genarr2.arr[0] = 'd';
genarr2.arr[1] = 'e';
genarr2.arr[2] = 'f';
genlist.somelist.Add (genarr2);
Serialize (genlist);
Assert.AreEqual (Infoset ("<GenListClassOfGenArrayClassOfChar xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist><GenArrayClassOfChar><arr><char>97</char><char>98</char><char>0</char></arr></GenArrayClassOfChar><GenArrayClassOfChar><arr><char>100</char><char>101</char><char>102</char></arr></GenArrayClassOfChar></somelist></GenListClassOfGenArrayClassOfChar>"), WriterText);
}
[Test]
public void TestSerializeGenTwoClassCharDouble ()
{
GenTwoClass<char, double> gentwo = new GenTwoClass<char, double> ();
Serialize (gentwo);
Assert.AreEqual (Infoset ("<GenTwoClassOfCharDouble xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something1>0</something1><something2>0</something2></GenTwoClassOfCharDouble>"), WriterText);
gentwo.something1 = 'a';
gentwo.something2 = 2.2;
Serialize (gentwo);
Assert.AreEqual (Infoset ("<GenTwoClassOfCharDouble xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something1>97</something1><something2>2.2</something2></GenTwoClassOfCharDouble>"), WriterText);
}
[Test]
public void TestSerializeGenDerivedClassDecimalShort ()
{
GenDerivedClass<decimal, short> derived = new GenDerivedClass<decimal, short> ();
Serialize (derived);
Assert.AreEqual (Infoset ("<GenDerivedClassOfDecimalInt16 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something2>0</something2><another1>0</another1><another2>0</another2></GenDerivedClassOfDecimalInt16>"), WriterText);
derived.something1 = "Value1";
derived.something2 = 1;
derived.another1 = 1.1M;
derived.another2 = -22;
Serialize (derived);
Assert.AreEqual (Infoset ("<GenDerivedClassOfDecimalInt16 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something1>Value1</something1><something2>1</something2><another1>1.1</another1><another2>-22</another2></GenDerivedClassOfDecimalInt16>"), WriterText);
}
[Test]
public void TestSerializeGenDerivedSecondClassByteUlong ()
{
GenDerived2Class<byte, ulong> derived2 = new GenDerived2Class<byte, ulong> ();
Serialize (derived2);
Assert.AreEqual (Infoset ("<GenDerived2ClassOfByteUInt64 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something1>0</something1><something2>0</something2><another1>0</another1><another2>0</another2></GenDerived2ClassOfByteUInt64>"), WriterText);
derived2.something1 = 1;
derived2.something2 = 222;
derived2.another1 = 111;
derived2.another2 = 222222;
Serialize (derived2);
Assert.AreEqual (Infoset ("<GenDerived2ClassOfByteUInt64 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something1>1</something1><something2>222</something2><another1>111</another1><another2>222222</another2></GenDerived2ClassOfByteUInt64>"), WriterText);
}
[Test]
public void TestSerializeGenNestedClass ()
{
GenNestedClass<string, int>.InnerClass<bool> nested =
new GenNestedClass<string, int>.InnerClass<bool> ();
Serialize (nested);
Assert.AreEqual (Infoset ("<InnerClassOfStringInt32Boolean xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><inner>0</inner><something>false</something></InnerClassOfStringInt32Boolean>"), WriterText);
nested.inner = 5;
nested.something = true;
Serialize (nested);
Assert.AreEqual (Infoset ("<InnerClassOfStringInt32Boolean xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><inner>5</inner><something>true</something></InnerClassOfStringInt32Boolean>"), WriterText);
}
[Test]
public void TestSerializeGenListClassListNested ()
{
GenListClass<GenListClass<GenNestedClass<int, int>.InnerClass<string>>> genlist =
new GenListClass<GenListClass<GenNestedClass<int, int>.InnerClass<string>>> ();
Serialize (genlist);
Assert.AreEqual (Infoset ("<GenListClassOfGenListClassOfInnerClassOfInt32Int32String xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist></somelist></GenListClassOfGenListClassOfInnerClassOfInt32Int32String>"), WriterText);
GenListClass<GenNestedClass<int, int>.InnerClass<string>> inlist1 =
new GenListClass<GenNestedClass<int, int>.InnerClass<string>> ();
GenNestedClass<int, int>.InnerClass<string> inval1 = new GenNestedClass<int, int>.InnerClass<string> ();
inval1.inner = 1;
inval1.something = "ONE";
inlist1.somelist.Add (inval1);
GenNestedClass<int, int>.InnerClass<string> inval2 = new GenNestedClass<int, int>.InnerClass<string> ();
inval2.inner = 2;
inval2.something = "TWO";
inlist1.somelist.Add (inval2);
GenListClass<GenNestedClass<int, int>.InnerClass<string>> inlist2 =
new GenListClass<GenNestedClass<int, int>.InnerClass<string>> ();
GenNestedClass<int, int>.InnerClass<string> inval3 = new GenNestedClass<int, int>.InnerClass<string> ();
inval3.inner = 30;
inval3.something = "THIRTY";
inlist2.somelist.Add (inval3);
genlist.somelist.Add (inlist1);
genlist.somelist.Add (inlist2);
Serialize (genlist);
Assert.AreEqual (Infoset ("<GenListClassOfGenListClassOfInnerClassOfInt32Int32String xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist><GenListClassOfInnerClassOfInt32Int32String><somelist><InnerClassOfInt32Int32String><inner>1</inner><something>ONE</something></InnerClassOfInt32Int32String><InnerClassOfInt32Int32String><inner>2</inner><something>TWO</something></InnerClassOfInt32Int32String></somelist></GenListClassOfInnerClassOfInt32Int32String><GenListClassOfInnerClassOfInt32Int32String><somelist><InnerClassOfInt32Int32String><inner>30</inner><something>THIRTY</something></InnerClassOfInt32Int32String></somelist></GenListClassOfInnerClassOfInt32Int32String></somelist></GenListClassOfGenListClassOfInnerClassOfInt32Int32String>"), WriterText);
}
public enum Myenum { one, two, three, four, five, six };
[Test]
public void TestSerializeGenArrayClassEnum ()
{
GenArrayClass<Myenum> genarr = new GenArrayClass<Myenum> ();
Serialize (genarr);
Assert.AreEqual (Infoset ("<GenArrayClassOfMyenum xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><arr><Myenum>one</Myenum><Myenum>one</Myenum><Myenum>one</Myenum></arr></GenArrayClassOfMyenum>"), WriterText);
genarr.arr[0] = Myenum.one;
genarr.arr[1] = Myenum.three;
genarr.arr[2] = Myenum.five;
Serialize (genarr);
Assert.AreEqual (Infoset ("<GenArrayClassOfMyenum xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><arr><Myenum>one</Myenum><Myenum>three</Myenum><Myenum>five</Myenum></arr></GenArrayClassOfMyenum>"), WriterText);
}
[Test]
public void TestSerializeGenArrayStruct ()
{
GenArrayClass<GenSimpleStruct<uint>> genarr = new GenArrayClass<GenSimpleStruct<uint>> ();
Serialize (genarr);
Assert.AreEqual ("<:GenArrayClassOfGenSimpleStructOfUInt32 http://www.w3.org/2000/xmlns/:xsd='http://www.w3.org/2001/XMLSchema' http://www.w3.org/2000/xmlns/:xsi='http://www.w3.org/2001/XMLSchema-instance'><:arr><:GenSimpleStructOfUInt32><:something>0</></><:GenSimpleStructOfUInt32><:something>0</></><:GenSimpleStructOfUInt32><:something>0</></></></>", WriterText);
GenSimpleStruct<uint> genstruct = new GenSimpleStruct<uint> ();
genstruct.something = 111;
genarr.arr[0] = genstruct;
genstruct.something = 222;
genarr.arr[1] = genstruct;
genstruct.something = 333;
genarr.arr[2] = genstruct;
Serialize (genarr);
Assert.AreEqual ("<:GenArrayClassOfGenSimpleStructOfUInt32 http://www.w3.org/2000/xmlns/:xsd='http://www.w3.org/2001/XMLSchema' http://www.w3.org/2000/xmlns/:xsi='http://www.w3.org/2001/XMLSchema-instance'><:arr><:GenSimpleStructOfUInt32><:something>111</></><:GenSimpleStructOfUInt32><:something>222</></><:GenSimpleStructOfUInt32><:something>333</></></></>", WriterText);
}
[Test]
public void TestSerializeGenArrayList ()
{
GenArrayClass<GenListClass<string>> genarr = new GenArrayClass<GenListClass<string>> ();
Serialize (genarr);
Assert.AreEqual ("<:GenArrayClassOfGenListClassOfString http://www.w3.org/2000/xmlns/:xsd='http://www.w3.org/2001/XMLSchema' http://www.w3.org/2000/xmlns/:xsi='http://www.w3.org/2001/XMLSchema-instance'><:arr><:GenListClassOfString http://www.w3.org/2001/XMLSchema-instance:nil='true'></><:GenListClassOfString http://www.w3.org/2001/XMLSchema-instance:nil='true'></><:GenListClassOfString http://www.w3.org/2001/XMLSchema-instance:nil='true'></></></>", WriterText);
GenListClass<string> genlist1 = new GenListClass<string> ();
genlist1.somelist.Add ("list1-val1");
genlist1.somelist.Add ("list1-val2");
genarr.arr[0] = genlist1;
GenListClass<string> genlist2 = new GenListClass<string> ();
genlist2.somelist.Add ("list2-val1");
genlist2.somelist.Add ("list2-val2");
genlist2.somelist.Add ("list2-val3");
genlist2.somelist.Add ("list2-val4");
genarr.arr[1] = genlist2;
GenListClass<string> genlist3 = new GenListClass<string> ();
genlist3.somelist.Add ("list3val");
genarr.arr[2] = genlist3;
Serialize (genarr);
Assert.AreEqual ("<:GenArrayClassOfGenListClassOfString http://www.w3.org/2000/xmlns/:xsd='http://www.w3.org/2001/XMLSchema' http://www.w3.org/2000/xmlns/:xsi='http://www.w3.org/2001/XMLSchema-instance'><:arr><:GenListClassOfString><:somelist><:string>list1-val1</><:string>list1-val2</></></><:GenListClassOfString><:somelist><:string>list2-val1</><:string>list2-val2</><:string>list2-val3</><:string>list2-val4</></></><:GenListClassOfString><:somelist><:string>list3val</></></></></>", WriterText);
}
[Test]
public void TestSerializeGenComplexStruct ()
{
GenComplexStruct<int, string> complex = new GenComplexStruct<int, string> (0);
Serialize (complex);
Assert.AreEqual ("<:GenComplexStructOfInt32String http://www.w3.org/2000/xmlns/:xsd='http://www.w3.org/2001/XMLSchema' http://www.w3.org/2000/xmlns/:xsi='http://www.w3.org/2001/XMLSchema-instance'><:something>0</><:simpleclass><:something>0</></><:simplestruct><:something>0</></><:listclass><:somelist></></><:arrayclass><:arr><:int>0</><:int>0</><:int>0</></></><:twoclass><:something1>0</></><:derivedclass><:something2>0</><:another1>0</></><:derived2><:something1>0</><:another1>0</></><:nestedouter><:outer>0</></><:nestedinner><:something>0</></></>", WriterText);
complex.something = 123;
complex.simpleclass.something = 456;
complex.simplestruct.something = 789;
GenListClass<int> genlist = new GenListClass<int> ();
genlist.somelist.Add (100);
genlist.somelist.Add (200);
complex.listclass = genlist;
GenArrayClass<int> genarr = new GenArrayClass<int> ();
genarr.arr[0] = 11;
genarr.arr[1] = 22;
genarr.arr[2] = 33;
complex.arrayclass = genarr;
complex.twoclass.something1 = 10;
complex.twoclass.something2 = "Ten";
complex.derivedclass.another1 = 1;
complex.derivedclass.another2 = "one";
complex.derivedclass.something1 = "two";
complex.derivedclass.something2 = 2;
complex.derived2.another1 = 3;
complex.derived2.another2 = "three";
complex.derived2.something1 = 4;
complex.derived2.something2 = "four";
complex.nestedouter.outer = 5;
complex.nestedinner.inner = "six";
complex.nestedinner.something = 6;
Serialize (complex);
Assert.AreEqual ("<:GenComplexStructOfInt32String http://www.w3.org/2000/xmlns/:xsd='http://www.w3.org/2001/XMLSchema' http://www.w3.org/2000/xmlns/:xsi='http://www.w3.org/2001/XMLSchema-instance'><:something>123</><:simpleclass><:something>456</></><:simplestruct><:something>789</></><:listclass><:somelist><:int>100</><:int>200</></></><:arrayclass><:arr><:int>11</><:int>22</><:int>33</></></><:twoclass><:something1>10</><:something2>Ten</></><:derivedclass><:something1>two</><:something2>2</><:another1>1</><:another2>one</></><:derived2><:something1>4</><:something2>four</><:another1>3</><:another2>three</></><:nestedouter><:outer>5</></><:nestedinner><:inner>six</><:something>6</></></>", WriterText);
}
[Test] // bug #80759
public void HasNullableField ()
{
Bug80759 foo = new Bug80759 ();
foo.Test = "BAR";
foo.NullableInt = 10;
XmlSerializer serializer = new XmlSerializer (typeof (Bug80759));
MemoryStream stream = new MemoryStream ();
serializer.Serialize (stream, foo);
stream.Position = 0;
foo = (Bug80759) serializer.Deserialize (stream);
}
[Test] // bug #80759, with fieldSpecified.
[ExpectedException (typeof (InvalidOperationException))]
[Category ("NotWorking")]
public void HasFieldSpecifiedButIrrelevant ()
{
Bug80759_2 foo = new Bug80759_2 ();
foo.Test = "BAR";
foo.NullableInt = 10;
XmlSerializer serializer = new XmlSerializer (typeof (Bug80759_2));
MemoryStream stream = new MemoryStream ();
serializer.Serialize (stream, foo);
stream.Position = 0;
foo = (Bug80759_2) serializer.Deserialize (stream);
}
[Test]
public void HasNullableField2 ()
{
Bug80759 foo = new Bug80759 ();
foo.Test = "BAR";
foo.NullableInt = 10;
XmlSerializer serializer = new XmlSerializer (typeof (Bug80759));
MemoryStream stream = new MemoryStream ();
serializer.Serialize (stream, foo);
stream.Position = 0;
foo = (Bug80759) serializer.Deserialize (stream);
Assert.AreEqual ("BAR", foo.Test, "#1");
Assert.AreEqual (10, foo.NullableInt, "#2");
foo.NullableInt = null;
stream = new MemoryStream ();
serializer.Serialize (stream, foo);
stream.Position = 0;
foo = (Bug80759) serializer.Deserialize (stream);
Assert.AreEqual ("BAR", foo.Test, "#3");
Assert.IsNull (foo.NullableInt, "#4");
}
[Test]
public void SupportPrivateCtorOnly ()
{
XmlSerializer xs =
new XmlSerializer (typeof (PrivateCtorOnly));
StringWriter sw = new StringWriter ();
xs.Serialize (sw, PrivateCtorOnly.Instance);
xs.Deserialize (new StringReader (sw.ToString ()));
}
[Test]
public void XmlSchemaProviderQNameBecomesRootName ()
{
xs = new XmlSerializer (typeof (XmlSchemaProviderQNameBecomesRootNameType));
Serialize (new XmlSchemaProviderQNameBecomesRootNameType ());
Assert.AreEqual (Infoset ("<foo />"), WriterText);
xs.Deserialize (new StringReader ("<foo/>"));
}
[Test]
public void XmlSchemaProviderQNameBecomesRootName2 ()
{
string xml = "<XmlSchemaProviderQNameBecomesRootNameType2 xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><Foo><foo /></Foo></XmlSchemaProviderQNameBecomesRootNameType2>";
xs = new XmlSerializer (typeof (XmlSchemaProviderQNameBecomesRootNameType2));
Serialize (new XmlSchemaProviderQNameBecomesRootNameType2 ());
Assert.AreEqual (Infoset (xml), WriterText);
xs.Deserialize (new StringReader (xml));
}
[Test]
public void XmlAnyElementForObjects () // bug #553032
{
new XmlSerializer (typeof (XmlAnyElementForObjectsType));
}
[Test]
[ExpectedException (typeof (InvalidOperationException))]
public void XmlAnyElementForObjects2 () // bug #553032-2
{
new XmlSerializer (typeof (XmlAnyElementForObjectsType)).Serialize (TextWriter.Null, new XmlAnyElementForObjectsType ());
}
public class Bug2893 {
public Bug2893 ()
{
Contents = new XmlDataDocument();
}
[XmlAnyElement("Contents")]
public XmlNode Contents;
}
// Bug Xamarin #2893
[Test]
public void XmlAnyElementForXmlNode ()
{
var obj = new Bug2893 ();
XmlSerializer mySerializer = new XmlSerializer(typeof(Bug2893));
XmlWriterSettings settings = new XmlWriterSettings();
var xsn = new XmlSerializerNamespaces();
xsn.Add(string.Empty, string.Empty);
byte[] buffer = new byte[2048];
var ms = new MemoryStream(buffer);
using (var xw = XmlWriter.Create(ms, settings))
{
mySerializer.Serialize(xw, obj, xsn);
xw.Flush();
}
mySerializer.Serialize(ms, obj);
}
[Test]
public void XmlRootOverridesSchemaProviderQName ()
{
var obj = new XmlRootOverridesSchemaProviderQNameType ();
XmlSerializer xs = new XmlSerializer (obj.GetType ());
var sw = new StringWriter ();
using (XmlWriter xw = XmlWriter.Create (sw))
xs.Serialize (xw, obj);
Assert.IsTrue (sw.ToString ().IndexOf ("foo") > 0, "#1");
}
public class AnotherArrayListType
{
[XmlAttribute]
public string one = "aaa";
[XmlAttribute]
public string another = "bbb";
}
public class DerivedArrayListType : AnotherArrayListType
{
}
public class ClassWithArrayList
{
[XmlElement (Type = typeof(int), ElementName = "int_elem")]
[XmlElement (Type = typeof(string), ElementName = "string_elem")]
[XmlElement (Type = typeof(AnotherArrayListType), ElementName = "another_elem")]
[XmlElement (Type = typeof(DerivedArrayListType), ElementName = "derived_elem")]
public ArrayList list;
}
public class ClassWithArray
{
[XmlElement (Type = typeof(int), ElementName = "int_elem")]
[XmlElement (Type = typeof(string), ElementName = "string_elem")]
[XmlElement (Type = typeof(AnotherArrayListType), ElementName = "another_elem")]
[XmlElement (Type = typeof(DerivedArrayListType), ElementName = "derived_elem")]
public object[] list;
}
[Test]
public void MultipleXmlElementAttributesOnArrayList()
{
var test = new ClassWithArrayList();
test.list = new ArrayList();
test.list.Add(3);
test.list.Add("apepe");
test.list.Add(new AnotherArrayListType());
test.list.Add(new DerivedArrayListType());
Serialize(test);
var expected_text = "<:ClassWithArrayList http://www.w3.org/2000/xmlns/:xsd='http://www.w3.org/2001/XMLSchema' http://www.w3.org/2000/xmlns/:xsi='http://www.w3.org/2001/XMLSchema-instance'><:int_elem>3</><:string_elem>apepe</><:another_elem :another='bbb' :one='aaa'></><:derived_elem :another='bbb' :one='aaa'></></>";
Assert.AreEqual(WriterText, expected_text, WriterText);
}
[Test]
public void MultipleXmlElementAttributesOnArray()
{
var test = new ClassWithArray();
test.list = new object[] { 3, "apepe", new AnotherArrayListType(), new DerivedArrayListType() };
Serialize(test);
var expected_text = "<:ClassWithArray http://www.w3.org/2000/xmlns/:xsd='http://www.w3.org/2001/XMLSchema' http://www.w3.org/2000/xmlns/:xsi='http://www.w3.org/2001/XMLSchema-instance'><:int_elem>3</><:string_elem>apepe</><:another_elem :another='bbb' :one='aaa'></><:derived_elem :another='bbb' :one='aaa'></></>";
Assert.AreEqual(WriterText, expected_text, WriterText);
}
#endif
#endregion //GenericsSeralizationTests
public class XmlArrayOnInt
{
[XmlArray]
public int Bogus;
}
public class XmlArrayUnqualifiedWithNamespace
{
[XmlArray (Namespace = "", Form = XmlSchemaForm.Unqualified)]
public ArrayList Sane = new ArrayList ();
}
public class XmlArrayItemUnqualifiedWithNamespace
{
[XmlArrayItem ("foo", Namespace = "", Form = XmlSchemaForm.Unqualified)]
public ArrayList Sane = new ArrayList ();
}
[XmlRoot (Namespace = "urn:foo")]
public class XmlArrayOnArrayList
{
[XmlArray (Form = XmlSchemaForm.Unqualified)]
public ArrayList Sane = new ArrayList ();
}
[XmlRoot (Namespace = "urn:foo")]
public class XmlArrayOnArray
{
[XmlArray (Form = XmlSchemaForm.Unqualified)]
public string[] Sane = new string[] { "foo", "bar" };
[XmlArray (Form = XmlSchemaForm.Unqualified)]
public ArrayItemInXmlArray[] Mids =
new ArrayItemInXmlArray[] { new ArrayItemInXmlArray () };
}
[XmlType (Namespace = "urn:gyabo")]
public class ArrayItemInXmlArray
{
[XmlArray (Form = XmlSchemaForm.Unqualified)]
public string[] Whee = new string[] { "foo", "bar" };
}
[XmlRoot ("Base64Binary")]
public class Base64Binary
{
[XmlAttribute (DataType = "base64Binary")]
public byte [] Data = new byte [] {1, 2, 3};
}
[XmlRoot ("HexBinary")]
public class HexBinary
{
[XmlAttribute (DataType = "hexBinary")]
public byte[] Data = new byte[] { 1, 2, 3 };
}
[XmlRoot ("PrivateCtorOnly")]
public class PrivateCtorOnly
{
public static PrivateCtorOnly Instance = new PrivateCtorOnly ();
private PrivateCtorOnly ()
{
}
}
public class CDataTextNodesType
{
public CDataTextNodesInternal foo;
}
public class CDataTextNodesInternal
{
[XmlText]
public string Value;
}
public class InvalidTypeContainer
{
[XmlElement (DataType = "invalid")]
public string InvalidTypeItem = "aaa";
}
public class TimeSpanContainer1
{
[XmlElement (DataType = "duration")]
public string StringDuration = "aaa";
}
public class TimeSpanContainer2
{
[XmlElement (DataType = "duration")]
public TimeSpan StringDuration = TimeSpan.FromSeconds (1);
}
#if NET_2_0
public class Bug80759
{
public string Test;
public int? NullableInt;
}
public class Bug80759_2
{
public string Test;
public int? NullableInt;
[XmlIgnore]
public bool NullableIntSpecified {
get { return NullableInt.HasValue; }
}
}
[XmlSchemaProvider ("GetXsdType")]
public class XmlSchemaProviderQNameBecomesRootNameType : IXmlSerializable
{
public XmlSchema GetSchema ()
{
return null;
}
public void ReadXml (XmlReader reader)
{
reader.Skip ();
}
public void WriteXml (XmlWriter writer)
{
}
public static XmlQualifiedName GetXsdType (XmlSchemaSet xss)
{
if (xss.Count == 0) {
XmlSchema xs = new XmlSchema ();
XmlSchemaComplexType ct = new XmlSchemaComplexType ();
ct.Name = "foo";
xs.Items.Add (ct);
xss.Add (xs);
}
return new XmlQualifiedName ("foo");
}
}
public class XmlSchemaProviderQNameBecomesRootNameType2
{
[XmlArrayItem (typeof (XmlSchemaProviderQNameBecomesRootNameType))]
public object [] Foo = new object [] {new XmlSchemaProviderQNameBecomesRootNameType ()};
}
public class XmlAnyElementForObjectsType
{
[XmlAnyElement]
public object [] arr = new object [] {3,4,5};
}
[XmlRoot ("foo")]
[XmlSchemaProvider ("GetSchema")]
public class XmlRootOverridesSchemaProviderQNameType : IXmlSerializable
{
public static XmlQualifiedName GetSchema (XmlSchemaSet xss)
{
var xs = new XmlSchema ();
var xse = new XmlSchemaComplexType () { Name = "bar" };
xs.Items.Add (xse);
xss.Add (xs);
return new XmlQualifiedName ("bar");
}
XmlSchema IXmlSerializable.GetSchema ()
{
return null;
}
void IXmlSerializable.ReadXml (XmlReader reader)
{
}
void IXmlSerializable.WriteXml (XmlWriter writer)
{
}
}
#endif
void CDataTextNodes_BadNode (object s, XmlNodeEventArgs e)
{
Assert.Fail ();
}
// Helper methods
public static string Infoset (string sx)
{
XmlDocument doc = new XmlDocument ();
doc.LoadXml (sx);
StringBuilder sb = new StringBuilder ();
GetInfoset (doc.DocumentElement, sb);
return sb.ToString ();
}
public static string Infoset (XmlNode nod)
{
StringBuilder sb = new StringBuilder ();
GetInfoset (nod, sb);
return sb.ToString ();
}
static void GetInfoset (XmlNode nod, StringBuilder sb)
{
switch (nod.NodeType) {
case XmlNodeType.Attribute:
if (nod.LocalName == "xmlns" && nod.NamespaceURI == "http://www.w3.org/2000/xmlns/") return;
sb.Append (" " + nod.NamespaceURI + ":" + nod.LocalName + "='" + nod.Value + "'");
break;
case XmlNodeType.Element:
XmlElement elem = (XmlElement) nod;
sb.Append ("<" + elem.NamespaceURI + ":" + elem.LocalName);
ArrayList ats = new ArrayList ();
foreach (XmlAttribute at in elem.Attributes)
ats.Add (at.LocalName + " " + at.NamespaceURI);
ats.Sort ();
foreach (string name in ats) {
string[] nn = name.Split (' ');
GetInfoset (elem.Attributes[nn[0], nn[1]], sb);
}
sb.Append (">");
foreach (XmlNode cn in elem.ChildNodes)
GetInfoset (cn, sb);
sb.Append ("</>");
break;
default:
sb.Append (nod.OuterXml);
break;
}
}
static XmlTypeMapping CreateSoapMapping (Type type)
{
SoapReflectionImporter importer = new SoapReflectionImporter ();
return importer.ImportTypeMapping (type);
}
static XmlTypeMapping CreateSoapMapping (Type type, SoapAttributeOverrides ao)
{
SoapReflectionImporter importer = new SoapReflectionImporter (ao);
return importer.ImportTypeMapping (type);
}
static XmlTypeMapping CreateSoapMapping (Type type, SoapAttributeOverrides ao, string defaultNamespace)
{
SoapReflectionImporter importer = new SoapReflectionImporter (ao, defaultNamespace);
return importer.ImportTypeMapping (type);
}
[XmlSchemaProvider (null, IsAny = true)]
public class AnySchemaProviderClass : IXmlSerializable {
public string Text;
void IXmlSerializable.WriteXml (XmlWriter writer)
{
writer.WriteElementString ("text", Text);
}
void IXmlSerializable.ReadXml (XmlReader reader)
{
Text = reader.ReadElementString ("text");
}
XmlSchema IXmlSerializable.GetSchema ()
{
return null;
}
}
[Test]
public void SerializeAnySchemaProvider ()
{
string expected = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
Environment.NewLine + "<text>test</text>";
var ser = new XmlSerializer (typeof (AnySchemaProviderClass));
var obj = new AnySchemaProviderClass {
Text = "test",
};
using (var t = new StringWriter ()) {
ser.Serialize (t, obj);
Assert.AreEqual (expected, t.ToString ());
}
}
[Test]
public void DeserializeAnySchemaProvider ()
{
string expected = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
Environment.NewLine + "<text>test</text>";
var ser = new XmlSerializer (typeof (AnySchemaProviderClass));
using (var t = new StringReader (expected)) {
var obj = (AnySchemaProviderClass) ser.Deserialize (t);
Assert.AreEqual ("test", obj.Text);
}
}
public class SubNoParameterlessConstructor : NoParameterlessConstructor
{
public SubNoParameterlessConstructor ()
: base ("")
{
}
}
public class NoParameterlessConstructor
{
[XmlElement ("Text")]
public string Text;
public NoParameterlessConstructor (string parameter)
{
}
}
[Test]
public void BaseClassWithoutParameterlessConstructor ()
{
var ser = new XmlSerializer (typeof (SubNoParameterlessConstructor));
var obj = new SubNoParameterlessConstructor {
Text = "test",
};
using (var w = new StringWriter ()) {
ser.Serialize (w, obj);
using (var r = new StringReader ( w.ToString ())) {
var desObj = (SubNoParameterlessConstructor) ser.Deserialize (r);
Assert.AreEqual (obj.Text, desObj.Text);
}
}
}
public class ClassWithXmlAnyElement
{
[XmlAnyElement ("Contents")]
public XmlNode Contents;
}
[Test] // bug #3211
public void TestClassWithXmlAnyElement ()
{
var d = new XmlDocument ();
var e = d.CreateElement ("Contents");
e.AppendChild (d.CreateElement ("SomeElement"));
var c = new ClassWithXmlAnyElement {
Contents = e,
};
var ser = new XmlSerializer (typeof (ClassWithXmlAnyElement));
using (var sw = new StringWriter ())
ser.Serialize (sw, c);
}
[Test]
public void ClassWithImplicitlyConvertibleElement ()
{
var ser = new XmlSerializer (typeof (ObjectWithElementRequiringImplicitCast));
var obj = new ObjectWithElementRequiringImplicitCast ("test");
using (var w = new StringWriter ()) {
ser.Serialize (w, obj);
using (var r = new StringReader ( w.ToString ())) {
var desObj = (ObjectWithElementRequiringImplicitCast) ser.Deserialize (r);
Assert.AreEqual (obj.Object.Text, desObj.Object.Text);
}
}
}
public class ClassWithOptionalMethods
{
private readonly bool shouldSerializeX;
private readonly bool xSpecified;
[XmlAttribute]
public int X { get; set; }
public bool ShouldSerializeX () { return shouldSerializeX; }
public bool XSpecified
{
get { return xSpecified; }
}
public ClassWithOptionalMethods ()
{
}
public ClassWithOptionalMethods (int x, bool shouldSerializeX, bool xSpecified)
{
this.X = x;
this.shouldSerializeX = shouldSerializeX;
this.xSpecified = xSpecified;
}
}
[Test]
public void OptionalMethods ()
{
var ser = new XmlSerializer (typeof (ClassWithOptionalMethods));
var expectedValueWithoutX = Infoset ("<?xml version=\"1.0\" encoding=\"utf-16\"?>" + Environment.NewLine +
"<ClassWithOptionalMethods xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" />");
var expectedValueWithX = Infoset ("<?xml version=\"1.0\" encoding=\"utf-16\"?>" + Environment.NewLine +
"<ClassWithOptionalMethods xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" X=\"11\" />");
using (var t = new StringWriter ()) {
var obj = new ClassWithOptionalMethods (11, false, false);
ser.Serialize (t, obj);
Assert.AreEqual (expectedValueWithoutX, Infoset (t.ToString ()));
}
using (var t = new StringWriter ()) {
var obj = new ClassWithOptionalMethods (11, true, false);
ser.Serialize (t, obj);
Assert.AreEqual (expectedValueWithoutX, Infoset (t.ToString ()));
}
using (var t = new StringWriter ()) {
var obj = new ClassWithOptionalMethods (11, false, true);
ser.Serialize (t, obj);
Assert.AreEqual (expectedValueWithoutX, Infoset (t.ToString ()));
}
using (var t = new StringWriter ()) {
var obj = new ClassWithOptionalMethods (11, true, true);
ser.Serialize (t, obj);
Assert.AreEqual (expectedValueWithX, Infoset (t.ToString ()));
}
}
public class ClassWithShouldSerializeGeneric
{
[XmlAttribute]
public int X { get; set; }
public bool ShouldSerializeX<T> () { return false; }
}
[Test]
[Category("NotDotNet")]
public void ShouldSerializeGeneric ()
{
var ser = new XmlSerializer (typeof (ClassWithShouldSerializeGeneric));
var expectedValueWithX = Infoset ("<?xml version=\"1.0\" encoding=\"utf-16\"?>" + Environment.NewLine +
"<ClassWithShouldSerializeGeneric xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" X=\"11\" />");
using (var t = new StringWriter ()) {
var obj = new ClassWithShouldSerializeGeneric { X = 11 };
ser.Serialize (t, obj);
Assert.AreEqual (expectedValueWithX, Infoset (t.ToString ()));
}
}
[Test]
public void NullableArrayItems ()
{
var ser = new XmlSerializer (typeof (ObjectWithNullableArrayItems));
var obj = new ObjectWithNullableArrayItems ();
obj.Elements = new List <SimpleClass> ();
obj.Elements.Add (new SimpleClass { something = "Hello" });
obj.Elements.Add (null);
obj.Elements.Add (new SimpleClass { something = "World" });
using (var w = new StringWriter ()) {
ser.Serialize (w, obj);
using (var r = new StringReader ( w.ToString ())) {
var desObj = (ObjectWithNullableArrayItems) ser.Deserialize (r);
Assert.IsNull (desObj.Elements [1]);
}
}
}
[Test]
public void NonNullableArrayItems ()
{
var ser = new XmlSerializer (typeof (ObjectWithNonNullableArrayItems));
var obj = new ObjectWithNonNullableArrayItems ();
obj.Elements = new List <SimpleClass> ();
obj.Elements.Add (new SimpleClass { something = "Hello" });
obj.Elements.Add (null);
obj.Elements.Add (new SimpleClass { something = "World" });
using (var w = new StringWriter ()) {
ser.Serialize (w, obj);
using (var r = new StringReader ( w.ToString ())) {
var desObj = (ObjectWithNonNullableArrayItems) ser.Deserialize (r);
Assert.IsNotNull (desObj.Elements [1]);
}
}
}
[Test]
public void NotSpecifiedNullableArrayItems ()
{
var ser = new XmlSerializer (typeof (ObjectWithNotSpecifiedNullableArrayItems));
var obj = new ObjectWithNotSpecifiedNullableArrayItems ();
obj.Elements = new List <SimpleClass> ();
obj.Elements.Add (new SimpleClass { something = "Hello" });
obj.Elements.Add (null);
obj.Elements.Add (new SimpleClass { something = "World" });
using (var w = new StringWriter ()) {
ser.Serialize (w, obj);
using (var r = new StringReader ( w.ToString ())) {
var desObj = (ObjectWithNotSpecifiedNullableArrayItems) ser.Deserialize (r);
Assert.IsNull (desObj.Elements [1]);
}
}
}
private static void TestClassWithDefaultTextNotNullAux (string value, string expected)
{
var obj = new ClassWithDefaultTextNotNull (value);
var ser = new XmlSerializer (typeof (ClassWithDefaultTextNotNull));
using (var mstream = new MemoryStream ())
using (var writer = new XmlTextWriter (mstream, Encoding.ASCII)) {
ser.Serialize (writer, obj);
mstream.Seek (0, SeekOrigin.Begin);
using (var reader = new XmlTextReader (mstream)) {
var result = (ClassWithDefaultTextNotNull) ser.Deserialize (reader);
Assert.AreEqual (expected, result.Value);
}
}
}
[Test]
public void TestClassWithDefaultTextNotNull ()
{
TestClassWithDefaultTextNotNullAux ("my_text", "my_text");
TestClassWithDefaultTextNotNullAux ("", ClassWithDefaultTextNotNull.DefaultValue);
TestClassWithDefaultTextNotNullAux (null, ClassWithDefaultTextNotNull.DefaultValue);
}
}
// Test generated serialization code.
public class XmlSerializerGeneratorTests : XmlSerializerTests {
private FieldInfo backgroundGeneration;
private FieldInfo generationThreshold;
private FieldInfo generatorFallback;
private bool backgroundGenerationOld;
private int generationThresholdOld;
private bool generatorFallbackOld;
[SetUp]
public void SetUp ()
{
// Make sure XmlSerializer static constructor is called
XmlSerializer.FromTypes (new Type [] {});
const BindingFlags binding = BindingFlags.Static | BindingFlags.NonPublic;
backgroundGeneration = typeof (XmlSerializer).GetField ("backgroundGeneration", binding);
generationThreshold = typeof (XmlSerializer).GetField ("generationThreshold", binding);
generatorFallback = typeof (XmlSerializer).GetField ("generatorFallback", binding);
if (backgroundGeneration == null)
Assert.Ignore ("Unable to access field backgroundGeneration");
if (generationThreshold == null)
Assert.Ignore ("Unable to access field generationThreshold");
if (generatorFallback == null)
Assert.Ignore ("Unable to access field generatorFallback");
backgroundGenerationOld = (bool) backgroundGeneration.GetValue (null);
generationThresholdOld = (int) generationThreshold.GetValue (null);
generatorFallbackOld = (bool) generatorFallback.GetValue (null);
backgroundGeneration.SetValue (null, false);
generationThreshold.SetValue (null, 0);
generatorFallback.SetValue (null, false);
}
[TearDown]
public void TearDown ()
{
if (backgroundGeneration == null || generationThreshold == null || generatorFallback == null)
return;
backgroundGeneration.SetValue (null, backgroundGenerationOld);
generationThreshold.SetValue (null, generationThresholdOld);
generatorFallback.SetValue (null, generatorFallbackOld);
}
}
}