context: //
  // System.Xml.XmlSerializerTestClasses
  //
  // Authors:
  //   Erik LeBel <eriklebel@yahoo.ca>
  //   Hagit Yidov <hagity@mainsoft.com>
  //
  // (C) 2003 Erik LeBel
  // (C) 2005 Mainsoft Corporation (http://www.mainsoft.com)
  //
  // Classes to use in the testing of the XmlSerializer
  //
  
  using System;
  using System.Collections;
  using System.Collections.Generic;
  using System.ComponentModel;
  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
  	}
  
  	#region GenericsTestClasses
  
  	public class GenSimpleClass<T>
  	{
  		public T something = default (T);
  	}
  
  	public struct GenSimpleStruct<T>
  	{
  		public T something;
  		public GenSimpleStruct (int dummy)
  		{
  			something = default (T);
  		}
  	}
  
  	public class GenListClass<T>
  	{
  		public List<T> somelist = new List<T> ();
  	}
  
  	public class GenArrayClass<T>
  	{
  		public T[] arr = new T[3];
  	}
  
  	public class GenTwoClass<T1, T2>
  	{
  		public T1 something1 = default (T1);
  		public T2 something2 = default (T2);
  	}
  
  	public class GenDerivedClass<T1, T2> : GenTwoClass<string, int>
  	{
  		public T1 another1 = default (T1);
  		public T2 another2 = default (T2);
  	}
  
  	public class GenDerived2Class<T1, T2> : GenTwoClass<T1, T2>
  	{
  		public T1 another1 = default (T1);
  		public T2 another2 = default (T2);
  	}
  
  	public class GenNestedClass<TO, TI>
  	{
  		public TO outer = default (TO);
  		public class InnerClass<T>
  		{
  			public TI inner = default (TI);
  			public T something = default (T);
  		}
  	}
  
  	public struct GenComplexStruct<T1, T2>
  	{
  		public T1 something;
  		public GenSimpleClass<T1> simpleclass;
  		public GenSimpleStruct<T1> simplestruct;
  		public GenListClass<T1> listclass;
  		public GenArrayClass<T1> arrayclass;
  		public GenTwoClass<T1, T2> twoclass;
  		public GenDerivedClass<T1, T2> derivedclass;
  		public GenDerived2Class<T1, T2> derived2;
  		public GenNestedClass<T1, T2> nestedouter;
  		public GenNestedClass<T1, T2>.InnerClass<T1> nestedinner;
  		public GenComplexStruct (int dummy)
  		{
  			something = default (T1);
  			simpleclass = new GenSimpleClass<T1> ();
  			simplestruct = new GenSimpleStruct<T1> ();
  			listclass = new GenListClass<T1> ();
  			arrayclass = new GenArrayClass<T1> ();
  			twoclass = new GenTwoClass<T1, T2> ();
  			derivedclass = new GenDerivedClass<T1, T2> ();
  			derived2 = new GenDerived2Class<T1, T2> ();
  			nestedouter = new GenNestedClass<T1, T2> ();
  			nestedinner = new GenNestedClass<T1, T2>.InnerClass<T1> ();
  		}
  	}
  		
  	public class WithNulls
  	{
  		[XmlElement (IsNullable=true)]
  		public int? nint;
  		
  		[XmlElement (IsNullable=true)]
  		public TestEnumWithNulls? nenum;
  		
  		[XmlElement (IsNullable=true)]
  		public DateTime? ndate;
  	}
  	
  	public enum TestEnumWithNulls
  	{
  		aa,
  		bb
  	}
  	
  
  	#endregion // GenericsTestClasses
  
  	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")]
  		[SoapEnum ("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" };
  		List<string> strList = new List<string> { "listString1" };
  
  		public string[] StrArr
  		{
  			get { return strArr; }
  		}
  
  		public string dat
  		{
  			get { return "fff"; }
  		}
  
  		public IList<string> StrList { get { return strList; } }
  	}
  
  	[Serializable]
  	public class ReadOnlyListProperty {
  		List<string> strList = new List<string> { "listString1", "listString2" };
  
  		public List<string> StrList
  		{
  			get { return strList; }
  		}
  	}
  
  
  	[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"; }
  		}
  
  
gt: 		[XmlArray (IsNullable = false)]