Files
mono/mcs/class/System.XML/Test/System.Xml.Serialization/XmlSerializerTestClasses.cs
T
Gert Driesen a99e0e1f9b * SoapAttributesTests.cs: Added tests for bug #78205.
* XmlSerializerTestClasses.cs: Added test classes and improved existing
classes for usage in upcoming bug reports.
* System.Xml_test.dll.sources: Added Test/System.Xml.Serialization/
SoapAttributesTests.cs.
* SoapAttributes.cs: The DefaultValueAttribute.Value should be returned
as SoapDefaultValue instead of the attribute itself. Fixes bug #78205.

svn path=/trunk/mcs/; revision=59917
2006-04-26 09:34:18 +00:00

696 lines
15 KiB
C#

//
// System.Xml.XmlSerializerTestClasses
//
// Author:
// Erik LeBel <[email protected]>
//
// (C) 2003 Erik LeBel
//
// Classes to use in the testing of the XmlSerializer
//
using System;
using System.ComponentModel;
using System.Collections;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
namespace MonoTests.System.Xml.TestClasses
{
public enum SimpleEnumeration { FIRST, SECOND };
[Flags]
public enum EnumDefaultValue { e1 = 1, e2 = 2, e3 = 3 }
public enum EnumDefaultValueNF { e1 = 1, e2 = 2, e3 = 3 }
[Flags]
public enum FlagEnum {
[XmlEnum ("one")]
e1 = 1,
[XmlEnum ("two")]
e2 = 2,
[XmlEnum ("four")]
e4 = 4
}
[Flags]
[SoapType ("flagenum")]
public enum FlagEnum_Encoded
{
[SoapEnum ("one")]
e1 = 1,
[SoapEnum ("two")]
e2 = 2,
[SoapEnum ("four")]
e4 = 4
}
[Flags]
public enum ZeroFlagEnum {
[XmlEnum ("zero")]
e0 = 0,
[XmlEnum ("o<n>e")]
e1 = 1,
[XmlEnum ("tns:t<w>o")]
e2 = 2,
[XmlEnum ("four")]
[XmlIgnore]
e4 = 4
}
public class SimpleClass
{
public string something = null;
}
public class StringCollection : CollectionBase
{
public void Add (String parameter)
{
List.Insert (Count, parameter);
}
public String this [int index]
{
get
{
if (index < 0 || index > Count)
throw new ArgumentOutOfRangeException ();
return (String) List [index];
}
set { List [index] = value; }
}
}
public class StringCollectionContainer
{
StringCollection messages = new StringCollection();
public StringCollection Messages
{
get { return messages; }
}
}
public class ArrayContainer
{
public object [] items = null;
}
public class ClassArrayContainer
{
public SimpleClass [] items = null;
}
[XmlRoot("simple")]
public class SimpleClassWithXmlAttributes
{
[XmlAttribute("member")]
public string something = null;
}
[XmlRoot("field")]
public class Field
{
[XmlAttribute ("flag1")]
[DefaultValue (1)]
public FlagEnum Flags1;
[XmlAttribute ("flag2")]
[DefaultValue (FlagEnum.e1)]
public FlagEnum Flags2;
[XmlAttribute ("flag3", Form = XmlSchemaForm.Qualified)]
[DefaultValue (FlagEnum.e1 | FlagEnum.e2)]
public FlagEnum Flags3;
[XmlAttribute ("flag4")]
public FlagEnum Flags4;
[XmlAttribute("modifiers")]
public MapModifiers Modifiers;
[XmlAttribute ("modifiers2", Form=XmlSchemaForm.Unqualified)]
public MapModifiers Modifiers2;
[XmlAttribute ("modifiers3")]
[DefaultValue (0)]
public MapModifiers Modifiers3;
[XmlAttribute ("modifiers4", Form=XmlSchemaForm.Unqualified)]
[DefaultValue (MapModifiers.Protected)]
public MapModifiers Modifiers4;
[XmlAttribute ("modifiers5", Form = XmlSchemaForm.Qualified)]
[DefaultValue (MapModifiers.Public)]
public MapModifiers Modifiers5;
[XmlAttribute ("names")]
public string[] Names;
[XmlAttribute ("street")]
public string Street;
}
[SoapType ("field", Namespace = "some:urn")]
public class Field_Encoded
{
[SoapAttribute ("flag1")]
[DefaultValue (FlagEnum_Encoded.e1)]
public FlagEnum_Encoded Flags1;
[SoapAttribute ("flag2")]
[DefaultValue (FlagEnum_Encoded.e1)]
public FlagEnum_Encoded Flags2;
[SoapAttribute ("flag3")]
[DefaultValue (FlagEnum_Encoded.e1 | FlagEnum_Encoded.e2)]
public FlagEnum_Encoded Flags3;
[SoapAttribute ("flag4")]
public FlagEnum_Encoded Flags4;
[SoapAttribute ("modifiers")]
public MapModifiers Modifiers;
[SoapAttribute ("modifiers2")]
public MapModifiers Modifiers2;
[SoapAttribute ("modifiers3")]
[DefaultValue (MapModifiers.Public)]
public MapModifiers Modifiers3;
[SoapAttribute ("modifiers4")]
[DefaultValue (MapModifiers.Protected)]
public MapModifiers Modifiers4;
[SoapAttribute ("modifiers5")]
[DefaultValue (MapModifiers.Public)]
public MapModifiers Modifiers5;
public string[] Names;
[SoapAttribute ("street")]
public string Street;
}
[Flags]
public enum MapModifiers
{
[XmlEnum("public")]
Public = 0,
[XmlEnum("protected")]
Protected = 1,
}
public class MyList : ArrayList
{
object container;
// NOTE: MyList has no public constructor
public MyList (object container) : base()
{
this.container = container;
}
}
public class Container
{
public MyList Items;
public Container () {
Items = new MyList(this);
}
}
public class Container2
{
public MyList Items;
public Container2 () {
}
public Container2 (bool b) {
Items = new MyList(this);
}
}
public class MyElem: XmlElement
{
public MyElem (XmlDocument doc): base ("","myelem","", doc)
{
SetAttribute ("aa","1");
}
[XmlAttribute]
public int kk=1;
}
public class MyDocument: XmlDocument
{
public MyDocument ()
{
}
[XmlAttribute]
public int kk=1;
}
public class CDataContainer
{
public XmlCDataSection cdata;
}
public class NodeContainer
{
public XmlNode node;
}
public class Choices
{
[XmlElementAttribute("ChoiceZero", typeof(string), IsNullable=false)]
[XmlElementAttribute("ChoiceOne", typeof(string), IsNullable=false)]
[XmlElementAttribute("ChoiceTwo", typeof(string), IsNullable=false)]
[XmlChoiceIdentifier("ItemType")]
public string MyChoice;
[XmlIgnore]
public ItemChoiceType ItemType;
}
[XmlType(IncludeInSchema = false)]
public enum ItemChoiceType
{
ChoiceZero,
[XmlEnum ("ChoiceOne")]
StrangeOne,
ChoiceTwo,
}
public class WrongChoices
{
[XmlElementAttribute("ChoiceZero", typeof(string), IsNullable=false)]
[XmlElementAttribute("StrangeOne", typeof(string), IsNullable=false)]
[XmlElementAttribute("ChoiceTwo", typeof(string), IsNullable=false)]
[XmlChoiceIdentifier("ItemType")]
public string MyChoice;
[XmlIgnore]
public ItemChoiceType ItemType;
}
[XmlType ("Type with space")]
public class TestSpace
{
[XmlElement (ElementName = "Element with space")]
public int elem;
[XmlAttribute (AttributeName = "Attribute with space")]
public int attr;
}
[Serializable]
public class ReadOnlyProperties {
string[] strArr = new string[2] { "string1", "string2" };
public string[] StrArr {
get { return strArr; }
}
public string dat {
get { return "fff"; }
}
}
[XmlRoot("root")]
public class ListDefaults
{
public ListDefaults ()
{
ed = new SimpleClass ();
str = "hola";
}
public ArrayList list2;
public MyList list3;
public string[] list4;
[XmlElement("e", typeof(SimpleClass))]
public ArrayList list5;
[DefaultValue (null)]
public SimpleClass ed;
[DefaultValue (null)]
public string str;
}
public class clsPerson
{
public IList EmailAccounts;
}
public class ArrayClass
{
public object names = new object[] { "un","dos" };
}
public class CompositeValueType
{
public void Init ()
{
Items = new object[] { 1, 2 };
ItemsElementName = new ItemsChoiceType[] { ItemsChoiceType.In, ItemsChoiceType.Es };
}
[XmlElementAttribute("Es", typeof(int))]
[XmlElementAttribute("In", typeof(int))]
[XmlChoiceIdentifierAttribute("ItemsElementName")]
public object[] Items;
[XmlElementAttribute("ItemsElementName")]
[XmlIgnoreAttribute()]
public ItemsChoiceType[] ItemsElementName;
}
public enum ItemsChoiceType {
In, Es
}
public class ArrayAttributeWithType
{
[XmlAttribute (DataType="anyURI")]
public string[] at = new string [] { "a","b" };
[XmlAttribute (DataType="base64Binary")]
public byte[][] bin1 = new byte[][] { new byte[]{1,2}, new byte[]{1,2}};
[XmlAttribute (DataType="base64Binary")]
public byte[] bin2 = new byte[] { 1,2 };
}
public class ArrayAttributeWithWrongType
{
[XmlAttribute (DataType="int")]
public string[] at = new string [] { "a","b" };
}
[XmlType ("Container")]
public class EntityContainer
{
EntityCollection collection1;
EntityCollection collection2;
EntityCollection collection3 = new EntityCollection ("root");
EntityCollection collection4 = new EntityCollection ("root");
[XmlArray (IsNullable=true)]
public EntityCollection Collection1 {
get { return collection1; }
set { collection1 = value; collection1.Container = "assigned"; }
}
[XmlArray (IsNullable=false)]
public EntityCollection Collection2 {
get { return collection2; }
set { collection2 = value; collection2.Container = "assigned"; }
}
[XmlArray (IsNullable=true)]
public EntityCollection Collection3 {
get { return collection3; }
set { collection3 = value; collection3.Container = "assigned"; }
}
[XmlArray (IsNullable=false)]
public EntityCollection Collection4 {
get { return collection4; }
set { collection4 = value; collection4.Container = "assigned"; }
}
}
[XmlType ("Container")]
public class ArrayEntityContainer
{
Entity[] collection1;
Entity[] collection2;
Entity[] collection3 = new Entity [0];
Entity[] collection4 = new Entity [0];
[XmlArray (IsNullable=true)]
public Entity[] Collection1 {
get { return collection1; }
set { collection1 = value; }
}
[XmlArray (IsNullable=false)]
public Entity[] Collection2 {
get { return collection2; }
set { collection2 = value; }
}
[XmlArray (IsNullable=true)]
public Entity[] Collection3 {
get { return collection3; }
set { collection3 = value; }
}
[XmlArray (IsNullable=false)]
public Entity[] Collection4 {
get { return collection4; }
set { collection4 = value; }
}
}
public class Entity
{
private string _name = string.Empty;
private string _parent = null;
[XmlAttribute]
public string Name {
get { return _name; }
set { _name = value; }
}
[XmlIgnore]
public string Parent {
get { return _parent; }
set { _parent = value; }
}
}
public class EntityCollection : ArrayList
{
public string _container;
public EntityCollection ()
{
}
public EntityCollection (string c)
{
_container = c;
}
public string Container {
get { return _container; }
set { _container = value; }
}
public int Add (Entity value)
{
if(_container != null)
value.Parent = _container;
return base.Add(value);
}
public new Entity this[int index]
{
get { return (Entity) base[index]; }
set { base[index] = value; }
}
}
[XmlType ("Container")]
public class ObjectWithReadonlyCollection
{
EntityCollection collection1 = new EntityCollection ("root");
public EntityCollection Collection1 {
get { return collection1; }
}
}
[XmlType ("Container")]
public class ObjectWithReadonlyNulCollection
{
EntityCollection collection1;
public EntityCollection Collection1 {
get { return collection1; }
}
}
[XmlType ("Container")]
public class ObjectWithReadonlyArray
{
Entity[] collection1 = new Entity [0];
public Entity[] Collection1 {
get { return collection1; }
}
}
[XmlInclude (typeof(SubclassTestSub))]
public class SubclassTestBase
{
}
public class SubclassTestSub: SubclassTestBase
{
}
public class SubclassTestExtra
{
}
public class SubclassTestContainer
{
[XmlElement ("a", typeof(SubclassTestBase))]
[XmlElement ("b", typeof(SubclassTestExtra))]
public object data;
}
public class DictionaryWithIndexer : DictionaryBase
{
public TimeSpan this[int index] {
get { return TimeSpan.MinValue; }
}
public void Add (TimeSpan value)
{
}
}
[XmlRoot(Namespace="some:urn")]
[SoapTypeAttribute (Namespace="another:urn")]
public class PrimitiveTypesContainer
{
public PrimitiveTypesContainer ()
{
Number = 2004;
Name = "some name";
Index = (byte) 56;
Password = new byte[] { 243, 15 };
PathSeparatorCharacter = '/';
}
public int Number;
public string Name;
public byte Index;
public byte[] Password;
public char PathSeparatorCharacter;
}
public class TestSchemaForm1
{
public PrintTypeResponse p1;
[XmlElement(Namespace="urn:oo")]
public PrintTypeResponse p2;
}
[XmlType (Namespace="urn:testForm")]
public class TestSchemaForm2
{
public PrintTypeResponse p1;
[XmlElement(Namespace="urn:oo")]
public PrintTypeResponse p2;
}
[XmlType (Namespace="urn:responseTypes")]
public class PrintTypeResponse {
[XmlElement (Form=XmlSchemaForm.Unqualified, IsNullable=true)]
public OutputType result;
public PrintTypeResponse intern;
public void Init ()
{
result = new OutputType ();
result.data = "data1";
intern = new PrintTypeResponse ();
intern.result = new OutputType ();
intern.result.data = "data2";
}
}
[XmlType (Namespace="urn:responseTypes")]
public class OutputType {
[XmlElement (Form=XmlSchemaForm.Unqualified, IsNullable=true)]
public string data;
}
[XmlRootAttribute ("testDefault", Namespace="urn:myNS", IsNullable=false)]
[SoapType("testDefault", Namespace="urn:myNS")]
public class TestDefault
{
public string str;
[DefaultValue ("Default Value")]
public string strDefault = "Default Value";
[DefaultValue (true)]
public bool boolT = true;
[DefaultValue (false)]
public bool boolF = false;
[DefaultValue (typeof (decimal), "10")]
public decimal decimalval = 10m;
[DefaultValue (FlagEnum.e1 | FlagEnum.e4)]
public FlagEnum flag = (FlagEnum.e1 | FlagEnum.e4);
[DefaultValue (FlagEnum_Encoded.e1 | FlagEnum_Encoded.e4)]
public FlagEnum_Encoded flagencoded = (FlagEnum_Encoded.e1 | FlagEnum_Encoded.e4);
}
[XmlType ("optionalValueType", Namespace="some:urn")]
[XmlRootAttribute ("optionalValue", Namespace="another:urn", IsNullable=false)]
public class OptionalValueTypeContainer
{
[DefaultValue (FlagEnum.e1 | FlagEnum.e4)]
public FlagEnum Attributes = FlagEnum.e1 | FlagEnum.e4;
[DefaultValue (FlagEnum.e1)]
public FlagEnum Flags = FlagEnum.e1;
[XmlIgnore]
[SoapIgnore]
public bool FlagsSpecified;
[DefaultValue (false)]
public bool IsEmpty;
[XmlIgnore]
[SoapIgnore]
public bool IsEmptySpecified {
get { return _isEmptySpecified; }
set { _isEmptySpecified = value; }
}
[DefaultValue (false)]
public bool IsNull;
private bool _isEmptySpecified;
}
}