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

   1 //
   2 // System.Xml.XmlSerializerTestClasses
   3 //
   4 // Authors:
   5 //   Erik LeBel <eriklebel@yahoo.ca>
   6 //   Hagit Yidov <hagity@mainsoft.com>
   7 //
   8 // (C) 2003 Erik LeBel
   9 // (C) 2005 Mainsoft Corporation (http://www.mainsoft.com)
  10 //
  11 // Classes to use in the testing of the XmlSerializer
  12 //
  13
  14 using System;
  15 using System.Collections;
  16 using System.Collections.Generic;
  17 using System.ComponentModel;
  18 using System.Xml;
  19 using System.Xml.Schema;
  20 using System.Xml.Serialization;
  21
  22 namespace MonoTests.System.Xml.TestClasses
  23 {
  24         public enum SimpleEnumeration { FIRST, SECOND };
  25
  26         [Flags]
  27         public enum EnumDefaultValue { e1 = 1, e2 = 2, e3 = 3 }
  28         public enum EnumDefaultValueNF { e1 = 1, e2 = 2, e3 = 3 }
  29
  30         [Flags]
  31         public enum FlagEnum
  32         {
  33                 [XmlEnum ("one")]
  34                 e1 = 1,
  35                 [XmlEnum ("two")]
  36                 e2 = 2,
  37                 [XmlEnum ("four")]
  38                 e4 = 4
  39         }
  40
  41         [Flags]
  42         [SoapType ("flagenum")]
  43         public enum FlagEnum_Encoded
  44         {
  45                 [SoapEnum ("one")]
  46                 e1 = 1,
  47                 [SoapEnum ("two")]
  48                 e2 = 2,
  49                 [SoapEnum ("four")]
  50                 e4 = 4
  51         }
  52
  53         [Flags]
  54         public enum ZeroFlagEnum
  55         {
  56                 [XmlEnum ("zero")]
  57                 e0 = 0,
  58                 [XmlEnum ("o<n>e")]
  59                 e1 = 1,
  60                 [XmlEnum ("tns:t<w>o")]
  61                 e2 = 2,
  62                 [XmlEnum ("four")]
  63                 [XmlIgnore]
  64                 e4 = 4
  65         }
  66
  67         #region GenericsTestClasses
  68
  69         public class GenSimpleClass<T>
  70         {
  71                 public T something = default (T);
  72         }
  73
  74         public struct GenSimpleStruct<T>
  75         {
  76                 public T something;
  77                 public GenSimpleStruct (int dummy)
  78                 {
  79                         something = default (T);
  80                 }
  81         }
  82
  83         public class GenListClass<T>
  84         {
  85                 public List<T> somelist = new List<T> ();
  86         }
  87
  88         public class GenArrayClass<T>
  89         {
  90                 public T[] arr = new T[3];
  91         }
  92
  93         public class GenTwoClass<T1, T2>
  94         {
  95                 public T1 something1 = default (T1);
  96                 public T2 something2 = default (T2);
  97         }
  98
  99         public class GenDerivedClass<T1, T2> : GenTwoClass<string, int>
 100         {
 101                 public T1 another1 = default (T1);
 102                 public T2 another2 = default (T2);
 103         }
 104
 105         public class GenDerived2Class<T1, T2> : GenTwoClass<T1, T2>
 106         {
 107                 public T1 another1 = default (T1);
 108                 public T2 another2 = default (T2);
 109         }
 110
 111         public class GenNestedClass<TO, TI>
 112         {
 113                 public TO outer = default (TO);
 114                 public class InnerClass<T>
 115                 {
 116                         public TI inner = default (TI);
 117                         public T something = default (T);
 118                 }
 119         }
 120
 121         public struct GenComplexStruct<T1, T2>
 122         {
 123                 public T1 something;
 124                 public GenSimpleClass<T1> simpleclass;
 125                 public GenSimpleStruct<T1> simplestruct;
 126                 public GenListClass<T1> listclass;
 127                 public GenArrayClass<T1> arrayclass;
 128                 public GenTwoClass<T1, T2> twoclass;
 129                 public GenDerivedClass<T1, T2> derivedclass;
 130                 public GenDerived2Class<T1, T2> derived2;
 131                 public GenNestedClass<T1, T2> nestedouter;
 132                 public GenNestedClass<T1, T2>.InnerClass<T1> nestedinner;
 133                 public GenComplexStruct (int dummy)
 134                 {
 135                         something = default (T1);
 136                         simpleclass = new GenSimpleClass<T1> ();
 137                         simplestruct = new GenSimpleStruct<T1> ();
 138                         listclass = new GenListClass<T1> ();
 139                         arrayclass = new GenArrayClass<T1> ();
 140                         twoclass = new GenTwoClass<T1, T2> ();
 141                         derivedclass = new GenDerivedClass<T1, T2> ();
 142                         derived2 = new GenDerived2Class<T1, T2> ();
 143                         nestedouter = new GenNestedClass<T1, T2> ();
 144                         nestedinner = new GenNestedClass<T1, T2>.InnerClass<T1> ();
 145                 }
 146         }
 147
 148         public class WithNulls
 149         {
 150                 [XmlElement (IsNullable=true)]
 151                 public int? nint;
 152
 153                 [XmlElement (IsNullable=true)]
 154                 public TestEnumWithNulls? nenum;
 155
 156                 [XmlElement (IsNullable=true)]
 157                 public DateTime? ndate;
 158         }
 159
 160         public enum TestEnumWithNulls
 161         {
 162                 aa,
 163                 bb
 164         }
 165
 166
 167         #endregion // GenericsTestClasses
 168
 169         public class SimpleClass
 170         {
 171                 public string something = null;
 172         }
 173
 174         public class StringCollection : CollectionBase
 175         {
 176                 public void Add (String parameter)
 177                 {
 178                         List.Insert (Count, parameter);
 179                 }
 180
 181                 public String this[int index]
 182                 {
 183                         get
 184                         {
 185                                 if (index < 0 || index > Count)
 186                                         throw new ArgumentOutOfRangeException ();
 187
 188                                 return (String) List[index];
 189                         }
 190                         set { List[index] = value; }
 191                 }
 192         }
 193
 194         public class StringCollectionContainer
 195         {
 196                 StringCollection messages = new StringCollection ();
 197
 198                 public StringCollection Messages
 199                 {
 200                         get { return messages; }
 201                 }
 202         }
 203
 204         public class ArrayContainer
 205         {
 206                 public object[] items = null;
 207         }
 208
 209         public class ClassArrayContainer
 210         {
 211                 public SimpleClass[] items = null;
 212         }
 213
 214         [XmlRoot ("simple")]
 215         public class SimpleClassWithXmlAttributes
 216         {
 217                 [XmlAttribute ("member")]
 218                 public string something = null;
 219         }
 220
 221         [XmlRoot ("field")]
 222         public class Field
 223         {
 224                 [XmlAttribute ("flag1")]
 225                 [DefaultValue (1)]
 226                 public FlagEnum Flags1;
 227
 228                 [XmlAttribute ("flag2")]
 229                 [DefaultValue (FlagEnum.e1)]
 230                 public FlagEnum Flags2;
 231
 232                 [XmlAttribute ("flag3", Form = XmlSchemaForm.Qualified)]
 233                 [DefaultValue (FlagEnum.e1 | FlagEnum.e2)]
 234                 public FlagEnum Flags3;
 235
 236                 [XmlAttribute ("flag4")]
 237                 public FlagEnum Flags4;
 238
 239                 [XmlAttribute ("modifiers")]
 240                 public MapModifiers Modifiers;
 241
 242                 [XmlAttribute ("modifiers2", Form = XmlSchemaForm.Unqualified)]
 243                 public MapModifiers Modifiers2;
 244
 245                 [XmlAttribute ("modifiers3")]
 246                 [DefaultValue (0)]
 247                 public MapModifiers Modifiers3;
 248
 249                 [XmlAttribute ("modifiers4", Form = XmlSchemaForm.Unqualified)]
 250                 [DefaultValue (MapModifiers.Protected)]
 251                 public MapModifiers Modifiers4;
 252
 253                 [XmlAttribute ("modifiers5", Form = XmlSchemaForm.Qualified)]
 254                 [DefaultValue (MapModifiers.Public)]
 255                 public MapModifiers Modifiers5;
 256
 257                 [XmlAttribute ("names")]
 258                 public string[] Names;
 259
 260                 [XmlAttribute ("street")]
 261                 public string Street;
 262         }
 263
 264         [SoapType ("field", Namespace = "some:urn")]
 265         public class Field_Encoded
 266         {
 267                 [SoapAttribute ("flag1")]
 268                 [DefaultValue (FlagEnum_Encoded.e1)]
 269                 public FlagEnum_Encoded Flags1;
 270
 271                 [SoapAttribute ("flag2")]
 272                 [DefaultValue (FlagEnum_Encoded.e1)]
 273                 public FlagEnum_Encoded Flags2;
 274
 275                 [SoapAttribute ("flag3")]
 276                 [DefaultValue (FlagEnum_Encoded.e1 | FlagEnum_Encoded.e2)]
 277                 public FlagEnum_Encoded Flags3;
 278
 279                 [SoapAttribute ("flag4")]
 280                 public FlagEnum_Encoded Flags4;
 281
 282                 [SoapAttribute ("modifiers")]
 283                 public MapModifiers Modifiers;
 284
 285                 [SoapAttribute ("modifiers2")]
 286                 public MapModifiers Modifiers2;
 287
 288                 [SoapAttribute ("modifiers3")]
 289                 [DefaultValue (MapModifiers.Public)]
 290                 public MapModifiers Modifiers3;
 291
 292                 [SoapAttribute ("modifiers4")]
 293                 [DefaultValue (MapModifiers.Protected)]
 294                 public MapModifiers Modifiers4;
 295
 296                 [SoapAttribute ("modifiers5")]
 297                 [DefaultValue (MapModifiers.Public)]
 298                 public MapModifiers Modifiers5;
 299
 300                 public string[] Names;
 301
 302                 [SoapAttribute ("street")]
 303                 public string Street;
 304         }
 305
 306         [Flags]
 307         public enum MapModifiers
 308         {
 309                 [XmlEnum ("public")]
 310                 [SoapEnum ("PuBlIc")]
 311                 Public = 0,
 312                 [XmlEnum ("protected")]
 313                 Protected = 1,
 314         }
 315
 316         public class MyList : ArrayList
 317         {
 318                 object container;
 319
 320                 // NOTE: MyList has no public constructor
 321                 public MyList (object container)
 322                         : base ()
 323                 {
 324                         this.container = container;
 325                 }
 326         }
 327
 328         public class Container
 329         {
 330                 public MyList Items;
 331
 332                 public Container ()
 333                 {
 334                         Items = new MyList (this);
 335                 }
 336         }
 337
 338         public class Container2
 339         {
 340                 public MyList Items;
 341
 342                 public Container2 ()
 343                 {
 344                 }
 345
 346                 public Container2 (bool b)
 347                 {
 348                         Items = new MyList (this);
 349                 }
 350         }
 351
 352         public class MyElem : XmlElement
 353         {
 354                 public MyElem (XmlDocument doc)
 355                         : base ("", "myelem", "", doc)
 356                 {
 357                         SetAttribute ("aa", "1");
 358                 }
 359
 360                 [XmlAttribute]
 361                 public int kk = 1;
 362         }
 363
 364         public class MyDocument : XmlDocument
 365         {
 366                 public MyDocument ()
 367                 {
 368                 }
 369
 370                 [XmlAttribute]
 371                 public int kk = 1;
 372         }
 373
 374         public class CDataContainer
 375         {
 376                 public XmlCDataSection cdata;
 377         }
 378
 379         public class NodeContainer
 380         {
 381                 public XmlNode node;
 382         }
 383
 384         public class Choices
 385         {
 386                 [XmlElementAttribute ("ChoiceZero", typeof (string), IsNullable = false)]
 387                 [XmlElementAttribute ("ChoiceOne", typeof (string), IsNullable = false)]
 388                 [XmlElementAttribute ("ChoiceTwo", typeof (string), IsNullable = false)]
 389                 [XmlChoiceIdentifier ("ItemType")]
 390                 public string MyChoice;
 391
 392                 [XmlIgnore]
 393                 public ItemChoiceType ItemType;
 394         }
 395
 396         [XmlType (IncludeInSchema = false)]
 397         public enum ItemChoiceType
 398         {
 399                 ChoiceZero,
 400                 [XmlEnum ("ChoiceOne")]
 401                 StrangeOne,
 402                 ChoiceTwo,
 403         }
 404
 405         public class WrongChoices
 406         {
 407                 [XmlElementAttribute ("ChoiceZero", typeof (string), IsNullable = false)]
 408                 [XmlElementAttribute ("StrangeOne", typeof (string), IsNullable = false)]
 409                 [XmlElementAttribute ("ChoiceTwo", typeof (string), IsNullable = false)]
 410                 [XmlChoiceIdentifier ("ItemType")]
 411                 public string MyChoice;
 412
 413                 [XmlIgnore]
 414                 public ItemChoiceType ItemType;
 415         }
 416
 417         [XmlType ("Type with space")]
 418         public class TestSpace
 419         {
 420                 [XmlElement (ElementName = "Element with space")]
 421                 public int elem;
 422
 423                 [XmlAttribute (AttributeName = "Attribute with space")]
 424                 public int attr;
 425         }
 426
 427         [Serializable]
 428         public class ReadOnlyProperties
 429         {
 430                 string[] strArr = new string[2] { "string1", "string2" };
 431                 List<string> strList = new List<string> { "listString1" };
 432
 433                 public string[] StrArr
 434                 {
 435                         get { return strArr; }
 436                 }
 437
 438                 public string dat
 439                 {
 440                         get { return "fff"; }
 441                 }
 442
 443                 public IList<string> StrList { get { return strList; } }
 444         }
 445
 446         [Serializable]
 447         public class ReadOnlyListProperty {
 448                 List<string> strList = new List<string> { "listString1", "listString2" };
 449
 450                 public List<string> StrList
 451                 {
 452                         get { return strList; }
 453                 }
 454         }
 455
 456
 457         [XmlRoot ("root")]
 458         public class ListDefaults
 459         {
 460                 public ListDefaults ()
 461                 {
 462                         ed = new SimpleClass ();
 463                         str = "hola";
 464                 }
 465
 466                 public ArrayList list2;
 467
 468 //              public MyList list3;
 469
 470                 public string[] list4;
 471
 472                 [XmlElement ("e", typeof (SimpleClass))]
 473                 public ArrayList list5;
 474
 475                 [DefaultValue (null)]
 476                 public SimpleClass ed;
 477
 478                 [DefaultValue (null)]
 479                 public string str;
 480         }
 481
 482         public class clsPerson
 483         {
 484                 public IList EmailAccounts;
 485         }
 486
 487         public class ArrayClass
 488         {
 489                 public object names = new object[] { "un", "dos" };
 490         }
 491
 492         public class CompositeValueType
 493         {
 494                 public void Init ()
 495                 {
 496                         Items = new object[] { 1, 2 };
 497                         ItemsElementName = new ItemsChoiceType[] { ItemsChoiceType.In, ItemsChoiceType.Es };
 498                 }
 499
 500                 [XmlElementAttribute ("Es", typeof (int))]
 501                 [XmlElementAttribute ("In", typeof (int))]
 502                 [XmlChoiceIdentifierAttribute ("ItemsElementName")]
 503                 public object[] Items;
 504
 505                 [XmlElementAttribute ("ItemsElementName")]
 506                 [XmlIgnoreAttribute ()]
 507                 public ItemsChoiceType[] ItemsElementName;
 508         }
 509
 510         public enum ItemsChoiceType
 511         {
 512                 In, Es
 513         }
 514
 515         public class ArrayAttributeWithType
 516         {
 517                 [XmlAttribute (DataType = "anyURI")]
 518                 public string[] at = new string[] { "a", "b" };
 519
 520                 [XmlAttribute (DataType = "base64Binary")]
 521                 public byte[][] bin1 = new byte[][] { new byte[] { 1, 2 }, new byte[] { 1, 2 } };
 522
 523                 [XmlAttribute (DataType = "base64Binary")]
 524                 public byte[] bin2 = new byte[] { 1, 2 };
 525         }
 526
 527         public class ArrayAttributeWithWrongType
 528         {
 529                 [XmlAttribute (DataType = "int")]
 530                 public string[] at = new string[] { "a", "b" };
 531         }
 532
 533         [XmlType ("Container")]
 534         public class EntityContainer
 535         {
 536                 EntityCollection collection1;
 537                 EntityCollection collection2;
 538                 EntityCollection collection3 = new EntityCollection ("root");
 539                 EntityCollection collection4 = new EntityCollection ("root");
 540
 541                 [XmlArray (IsNullable = true)]
 542                 public EntityCollection Collection1
 543                 {
 544                         get { return collection1; }
 545                         set { collection1 = value; collection1.Container = "assigned"; }
 546                 }
 547
 548                 [XmlArray (IsNullable = false)]
 549                 public EntityCollection Collection2
 550                 {
 551                         get { return collection2; }
 552                         set { collection2 = value; collection2.Container = "assigned"; }
 553                 }
 554
 555                 [XmlArray (IsNullable = true)]
 556                 public EntityCollection Collection3
 557                 {
 558                         get { return collection3; }
 559                         set { collection3 = value; collection3.Container = "assigned"; }
 560                 }
 561
 562                 [XmlArray (IsNullable = false)]
 563                 public EntityCollection Collection4
 564                 {
 565                         get { return collection4; }
 566                         set { collection4 = value; collection4.Container = "assigned"; }
 567                 }
 568         }
 569
 570         [XmlType ("Container")]
 571         public class ArrayEntityContainer
 572         {
 573                 Entity[] collection1;
 574                 Entity[] collection2;
 575                 Entity[] collection3 = new Entity[0];
 576                 Entity[] collection4 = new Entity[0];
 577
 578                 [XmlArray (IsNullable = true)]
 579                 public Entity[] Collection1
 580                 {
 581                         get { return collection1; }
 582                         set { collection1 = value; }
 583                 }
 584
 585                 [XmlArray (IsNullable = false)]
 586                 public Entity[] Collection2
 587                 {
 588                         get { return collection2; }
 589                         set { collection2 = value; }
 590                 }
 591
 592                 [XmlArray (IsNullable = true)]
 593                 public Entity[] Collection3
 594                 {
 595                         get { return collection3; }
 596                         set { collection3 = value; }
 597                 }
 598
 599                 [XmlArray (IsNullable = false)]
 600                 public Entity[] Collection4
 601                 {
 602                         get { return collection4; }
 603                         set { collection4 = value; }
 604                 }
 605         }
 606
 607         public class Entity
 608         {
 609                 private string _name = string.Empty;
 610                 private string _parent = null;
 611
 612                 [XmlAttribute]
 613                 public string Name
 614                 {
 615                         get { return _name; }
 616                         set { _name = value; }
 617                 }
 618
 619                 [XmlIgnore]
 620                 public string Parent
 621                 {
 622                         get { return _parent; }
 623                         set { _parent = value; }
 624                 }
 625         }
 626
 627         public class EntityCollection : ArrayList
 628         {
 629                 public string _container;
 630
 631                 public EntityCollection ()
 632                 {
 633                 }
 634
 635                 public EntityCollection (string c)
 636                 {
 637                         _container = c;
 638                 }
 639
 640                 public string Container
 641                 {
 642                         get { return _container; }
 643                         set { _container = value; }
 644                 }
 645
 646                 public int Add (Entity value)
 647                 {
 648                         if (_container != null)
 649                                 value.Parent = _container;
 650
 651                         return base.Add (value);
 652                 }
 653
 654                 public new Entity this[int index]
 655                 {
 656                         get { return (Entity) base[index]; }
 657                         set { base[index] = value; }
 658                 }
 659         }
 660
 661         [XmlType ("Container")]
 662         public class ObjectWithReadonlyCollection
 663         {
 664                 EntityCollection collection1 = new EntityCollection ("root");
 665
 666                 public EntityCollection Collection1
 667                 {
 668                         get { return collection1; }
 669                 }
 670         }
 671
 672         [XmlType ("Container")]
 673         public class ObjectWithReadonlyNulCollection
 674         {
 675                 EntityCollection collection1;
 676
 677                 public EntityCollection Collection1
 678                 {
 679                         get { return collection1; }
 680                 }
 681         }
 682
 683         [XmlType ("Container")]
 684         public class ObjectWithReadonlyArray
 685         {
 686                 Entity[] collection1 = new Entity[0];
 687
 688                 public Entity[] Collection1
 689                 {
 690                         get { return collection1; }
 691                 }
 692         }
 693
 694         [XmlInclude (typeof (SubclassTestSub))]
 695         public class SubclassTestBase
 696         {
 697         }
 698
 699         public class SubclassTestSub : SubclassTestBase
 700         {
 701         }
 702
 703         public class SubclassTestExtra
 704         {
 705         }
 706
 707         public class SubclassTestContainer
 708         {
 709                 [XmlElement ("a", typeof (SubclassTestBase))]
 710                 [XmlElement ("b", typeof (SubclassTestExtra))]
 711                 public object data;
 712         }
 713
 714         public class SubclassTestList
 715         {
 716                 [XmlElement ("a", typeof (SimpleClass))]
 717                 [XmlElement ("b", typeof (SubclassTestBase))]
 718                 public List<object> Items;
 719         }
 720
 721         public class DictionaryWithIndexer : DictionaryBase
 722         {
 723                 public TimeSpan this[int index]
 724                 {
 725                         get { return TimeSpan.MinValue; }
 726                 }
 727
 728                 public void Add (TimeSpan value)
 729                 {
 730                 }
 731         }
 732
 733         [XmlRoot (Namespace = "some:urn")]
 734         [SoapTypeAttribute (Namespace = "another:urn")]
 735         public class PrimitiveTypesContainer
 736         {
 737                 public PrimitiveTypesContainer ()
 738                 {
 739                         Number = 2004;
 740                         Name = "some name";
 741                         Index = (byte) 56;
 742                         Password = new byte[] { 243, 15 };
 743                         PathSeparatorCharacter = '/';
 744                 }
 745
 746                 public int Number;
 747                 public string Name;
 748                 public byte Index;
 749                 public byte[] Password;
 750                 public char PathSeparatorCharacter;
 751         }
 752
 753         public class TestSchemaForm1
 754         {
 755                 public PrintTypeResponse p1;
 756
 757                 [XmlElement (Namespace = "urn:oo")]
 758                 public PrintTypeResponse p2;
 759         }
 760
 761         [XmlType (Namespace = "urn:testForm")]
 762         public class TestSchemaForm2
 763         {
 764                 public PrintTypeResponse p1;
 765
 766                 [XmlElement (Namespace = "urn:oo")]
 767                 public PrintTypeResponse p2;
 768         }
 769
 770         [XmlType (Namespace = "urn:responseTypes")]
 771         public class PrintTypeResponse
 772         {
 773                 [XmlElement (Form = XmlSchemaForm.Unqualified, IsNullable = true)]
 774                 public OutputType result;
 775                 public PrintTypeResponse intern;
 776
 777                 public void Init ()
 778                 {
 779                         result = new OutputType ();
 780                         result.data = "data1";
 781                         intern = new PrintTypeResponse ();
 782                         intern.result = new OutputType ();
 783                         intern.result.data = "data2";
 784                 }
 785         }
 786
 787         [XmlType (Namespace = "urn:responseTypes")]
 788         public class OutputType
 789         {
 790
 791                 [XmlElement (Form = XmlSchemaForm.Unqualified, IsNullable = true)]
 792                 public string data;
 793         }
 794
 795         [XmlRootAttribute ("testDefault", Namespace = "urn:myNS", IsNullable = false)]
 796         [SoapType ("testDefault", Namespace = "urn:myNS")]
 797         public class TestDefault
 798         {
 799                 public string str;
 800
 801                 [DefaultValue ("Default Value")]
 802                 public string strDefault = "Default Value";
 803
 804                 [DefaultValue (true)]
 805                 public bool boolT = true;
 806
 807                 [DefaultValue (false)]
 808                 public bool boolF = false;
 809
 810                 [DefaultValue (typeof (decimal), "10")]
 811                 public decimal decimalval = 10m;
 812
 813                 [DefaultValue (FlagEnum.e1 | FlagEnum.e4)]
 814                 public FlagEnum flag = (FlagEnum.e1 | FlagEnum.e4);
 815
 816                 [DefaultValue (FlagEnum_Encoded.e1 | FlagEnum_Encoded.e4)]
 817                 public FlagEnum_Encoded flagencoded = (FlagEnum_Encoded.e1 | FlagEnum_Encoded.e4);
 818         }
 819
 820         [XmlType ("optionalValueType", Namespace = "some:urn")]
 821         [XmlRootAttribute ("optionalValue", Namespace = "another:urn", IsNullable = false)]
 822         public class OptionalValueTypeContainer
 823         {
 824                 [DefaultValue (FlagEnum.e1 | FlagEnum.e4)]
 825                 public FlagEnum Attributes = FlagEnum.e1 | FlagEnum.e4;
 826
 827                 [DefaultValue (FlagEnum.e1)]
 828                 public FlagEnum Flags = FlagEnum.e1;
 829
 830                 [XmlIgnore]
 831                 [SoapIgnore]
 832                 public bool FlagsSpecified;
 833
 834                 [DefaultValue (false)]
 835                 public bool IsEmpty;
 836
 837                 [XmlIgnore]
 838                 [SoapIgnore]
 839                 public bool IsEmptySpecified
 840                 {
 841                         get { return _isEmptySpecified; }
 842                         set { _isEmptySpecified = value; }
 843                 }
 844
 845                 [DefaultValue (false)]
 846                 public bool IsNull;
 847
 848                 private bool _isEmptySpecified;
 849         }
 850
 851         public class Group
 852         {
 853                 [SoapAttribute (Namespace = "http://www.cpandl.com")]
 854                 public string GroupName;
 855
 856                 [SoapAttribute (DataType = "base64Binary")]
 857                 public Byte[] GroupNumber;
 858
 859                 [SoapAttribute (DataType = "date", AttributeName = "CreationDate")]
 860                 public DateTime Today;
 861
 862                 [SoapElement (DataType = "nonNegativeInteger", ElementName = "PosInt")]
 863                 public string PostitiveInt;
 864
 865                 [SoapIgnore]
 866                 public bool IgnoreThis;
 867
 868                 [DefaultValue (GroupType.B)]
 869                 public GroupType Grouptype;
 870                 public Vehicle MyVehicle;
 871
 872                 [SoapInclude (typeof (Car))]
 873                 public Vehicle myCar (string licNumber)
 874                 {
 875                         Vehicle v;
 876                         if (licNumber == string.Empty) {
 877                                 v = new Car ();
 878                                 v.licenseNumber = "!!!!!!";
 879                         }
 880                         else {
 881                                 v = new Car ();
 882                                 v.licenseNumber = licNumber;
 883                         }
 884                         return v;
 885                 }
 886         }
 887
 888         [SoapInclude (typeof (Car))]
 889         public abstract class Vehicle
 890         {
 891                 public string licenseNumber;
 892                 [SoapElement (DataType = "date")]
 893                 public DateTime makeDate;
 894                 [DefaultValue ("450")]
 895                 public string weight;
 896         }
 897
 898         public class Car : Vehicle
 899         {
 900         }
 901
 902         public enum GroupType
 903         {
 904                 [SoapEnum ("Small")]
 905                 A,
 906                 [SoapEnum ("Large")]
 907                 B
 908         }
 909
 910         public class ErrorneousGetSchema : IXmlSerializable
 911         {
 912                 public XmlSchema GetSchema ()
 913                 {
 914                         throw new ApplicationException ("unexpected");
 915                 }
 916
 917                 public void ReadXml (XmlReader reader)
 918                 {
 919                 }
 920
 921                 public void WriteXml (XmlWriter writer)
 922                 {
 923                 }
 924
 925                 // it should be serialized IF it is NOT IXmlSerializable.
 926                 public string Whoa = "whoa";
 927         }
 928
 929         [XmlRoot ("DefaultDateTimeContainer", Namespace = "urn:foo")]
 930         public class DefaultDateTimeContainer // bug #378696
 931         {
 932                 public DateTime SimpleDateTime;
 933
 934                 [DefaultValue(typeof(DateTime), "2001-02-03T04:05:06")]
 935                 public DateTime FancyDateTime;
 936
 937                 [DefaultValue (typeof (int), "123456")]
 938                 public int Numeric;
 939         }
 940
 941         public class XmlSerializableImplicitConvertible
 942         {
 943                 public BaseClass B = new DerivedClass ();
 944
 945                 public class XmlSerializable : IXmlSerializable
 946                 {
 947                         public void WriteXml (XmlWriter writer)
 948                         {
 949                         }
 950
 951                         public void ReadXml (XmlReader reader)
 952                         {
 953                         }
 954
 955                         public XmlSchema GetSchema ()
 956                         {
 957                                 return null;
 958                         }
 959                 }
 960
 961                 public class BaseClass
 962                 {
 963                         public static implicit operator XmlSerializable (BaseClass b)
 964                         {
 965                                 return new XmlSerializable ();
 966
 967                         }
 968
 969                         public static implicit operator BaseClass (XmlSerializable x)
 970                         {
 971                                 return new BaseClass ();
 972                         }
 973                 }
 974
 975                 public class DerivedClass : BaseClass
 976                 {
 977                 }
 978         }
 979
 980         public class Bug704813Type
 981         {
 982                 IEnumerable<string> foo = new List<string> ();
 983                 public IEnumerable<string> Foo {
 984                         get { return foo; }
 985                 }
 986         }
 987
 988         public class Bug708178Type
 989         {
 990                 List<string> foo = new List<string> ();
 991
 992                 [XmlArray("Foo"), XmlArrayItem("Foo", typeof(string))]
 993                 public List<string> Foo {
 994                         get { return foo; }
 995                 }
 996         }
 997
 998         [XmlRoot("root")]
 999         public class ExplicitlyOrderedMembersType1
1000         {
1001                 [XmlElement("child0", Order = 4)]
1002                 public string Child0;
1003
1004                 [XmlElement("child", Order = 0)]
1005                 public string Child1;
1006
1007                 [XmlElement("child", Order = 2)]
1008                 public string Child2;
1009         }
1010
1011         [XmlRoot("root")]
1012         public class ExplicitlyOrderedMembersType2
1013         {
1014                 [XmlElement("child0", Order = 4)]
1015                 public string Child0;
1016
1017                 [XmlElement("child")] // wrong. Needs to be Ordered as well.
1018                 public string Child1;
1019
1020                 [XmlElement("child", Order = 2)]
1021                 public string Child2;
1022         }
1023
1024         [XmlRoot("root")]
1025         public class ExplicitlyOrderedMembersType3
1026         {
1027                 [XmlElement("child0", Order = 1)] // it's between 0 and 2. After two "child" elements, child0 is not recognized as this member.
1028                 public string Child0;
1029
1030                 [XmlElement("child", Order = 0)]
1031                 public string Child1;
1032
1033                 [XmlElement("child", Order = 2)]
1034                 public string Child2;
1035         }
1036
1037         [XmlRoot("root")]
1038         public class ExplicitlyOrderedMembersType4
1039         {
1040                 [XmlElement("child0", Order = 1)] // it's between 0 and 2. After two "child" elements, child0 is not recognized as this member.
1041                 public string Child0;
1042
1043                 [XmlElement("child", Order = 0)]
1044                 public string Child1;
1045
1046                 [XmlElement("child", Order = 2)]
1047                 public string Child2;
1048
1049                 [XmlAttribute]
1050                 public string Child3;
1051         }
1052
1053         [XmlRoot ("root")]
1054         public class NullableDatesAndTimes {
1055                 [XmlElementAttribute ("MyTime", DataType = "time", IsNullable = false)]
1056                 public DateTime MyTime;
1057
1058                 [XmlElementAttribute ("MyTimeNullable", DataType = "time", IsNullable = true)]
1059                 public DateTime? MyTimeNullable;
1060
1061                 [XmlElementAttribute ("MyDate", DataType = "date", IsNullable = false)]
1062                 public DateTime MyDate;
1063
1064                 [XmlElementAttribute ("MyDateNullable", DataType = "date", IsNullable = true)]
1065                 public DateTime? MyDateNullable;
1066         }
1067
1068         public class NotExactDateParseClass
1069         {
1070                 [XmlElementAttribute (DataType = "date")]
1071                 public DateTime SomeDate;
1072         }
1073
1074         public class UtcTimeClass
1075         {
1076                 [XmlElementAttribute (DataType = "time")]
1077                 public DateTime DateTimeValue;
1078         }
1079
1080         public class Bug8468BaseClass
1081         {
1082                 public string Base;
1083         }
1084
1085         public class Bug8468MidClass: Bug8468BaseClass
1086         {
1087                 public string Mid;
1088         }
1089
1090         [XmlRoot("Test", Namespace="http://test-namespace")]
1091         public class Bug8468Subclass: Bug8468MidClass
1092         {
1093         }
1094
1095         [XmlRoot("Test")]
1096         public class Bug8468SubclassNoNamespace: Bug8468MidClass
1097         {
1098         }
1099
1100         [XmlRoot("Test", Namespace="")]
1101         public class Bug8468BaseClassV2
1102         {
1103                 public string Base;
1104         }
1105
1106         public class Bug8468MidClassV2: Bug8468BaseClassV2
1107         {
1108                 public string Mid;
1109         }
1110
1111         [XmlRoot("Test", Namespace="http://test-namespace")]
1112         public class Bug8468SubclassV2: Bug8468MidClassV2
1113         {
1114         }
1115
1116         [XmlRoot("Test")]
1117         public class Bug8468SubclassNoNamespaceV2: Bug8468MidClassV2
1118         {
1119         }
1120
1121         [XmlRoot("Test")]
1122         public class Bug9193Class
1123         {
1124                 [XmlElement ("Data", Order=0)]
1125                 public string[] Data;
1126                 [XmlElement ("Extra", Order=1)]
1127                 public string[] Extra;
1128         }
1129
1130         public class SimpleObjectA
1131         {
1132                 [XmlAttribute]
1133                 public string Text
1134                 {
1135                         get; set;
1136                 }
1137
1138                 public static implicit operator SimpleObjectA (SimpleObjectB o)
1139                 {
1140                         return new SimpleObjectA { Text = o.Text };
1141                 }
1142
1143                 public static implicit operator SimpleObjectB (SimpleObjectA o)
1144                 {
1145                  return new SimpleObjectB { Text = o.Text };
1146                 }
1147         }
1148
1149         public class SimpleObjectB
1150         {
1151                 [XmlAttribute]
1152                 public string Text
1153                 {
1154                         get; set;
1155                 }
1156         }
1157
1158         public class ObjectWithElementRequiringImplicitCast
1159         {
1160                 public ObjectWithElementRequiringImplicitCast () { }
1161                 public ObjectWithElementRequiringImplicitCast (string text)
1162                 {
1163                         Object = new SimpleObjectB { Text = text };
1164                 }
1165
1166                 [XmlElement(Type = typeof (SimpleObjectA))]
1167                 public SimpleObjectB Object
1168                 {
1169                         get; set;
1170                 }
1171         }
1172
1173         public class ObjectWithNullableArrayItems
1174         {
1175                 [XmlArrayItem ("Element", IsNullable = true)]
1176                 public List<SimpleClass> Elements;
1177         }
1178
1179         public class ObjectWithNonNullableArrayItems
1180         {
1181                 [XmlArrayItem ("Element", IsNullable = false)]
1182                 public List<SimpleClass> Elements;
1183         }
1184
1185         public class ObjectWithNotSpecifiedNullableArrayItems
1186         {
1187                 [XmlArrayItem ("Element")]
1188                 public List<SimpleClass> Elements;
1189         }
1190
1191         [Serializable]
1192         public sealed class ClassWithDefaultTextNotNull
1193         {
1194                 [XmlText]
1195                 public string Value;
1196
1197                 public const string DefaultValue = "NotNull";
1198
1199                 public ClassWithDefaultTextNotNull (string v) {
1200                         Value = v;
1201                 }
1202
1203                 public ClassWithDefaultTextNotNull () {
1204                         Value = DefaultValue;
1205                 }
1206     }
1207 }
1208