mono/mcs/class/System.XML/Test/System.Xml.Serialization/XmlSerializerTestClasses.cs

//
// 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;
	}
}