mcs/class/System.Xaml/Test/System.Xaml/XamlObjectReaderTest.cs

   1 //
   2 // Copyright (C) 2010 Novell Inc. http://novell.com
   3 //
   4 // Permission is hereby granted, free of charge, to any person obtaining
   5 // a copy of this software and associated documentation files (the
   6 // "Software"), to deal in the Software without restriction, including
   7 // without limitation the rights to use, copy, modify, merge, publish,
   8 // distribute, sublicense, and/or sell copies of the Software, and to
   9 // permit persons to whom the Software is furnished to do so, subject to
  10 // the following conditions:
  11 //
  12 // The above copyright notice and this permission notice shall be
  13 // included in all copies or substantial portions of the Software.
  14 //
  15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  19 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  20 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  21 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22 //
  23 using System;
  24 using System.Collections;
  25 using System.Collections.Generic;
  26 using System.ComponentModel;
  27 using System.IO;
  28 using System.Linq;
  29 using System.Reflection;
  30 using System.Windows.Markup;
  31 using System.Xaml;
  32 using System.Xaml.Schema;
  33 using System.Xml;
  34 using NUnit.Framework;
  35
  36 using CategoryAttribute = NUnit.Framework.CategoryAttribute;
  37
  38 namespace MonoTests.System.Xaml
  39 {
  40         [TestFixture]
  41         public partial class XamlObjectReaderTest : XamlReaderTestBase
  42         {
  43                 [Test]
  44                 public void ConstructorNullObject ()
  45                 {
  46                         // allowed.
  47                         new XamlObjectReader (null);
  48                 }
  49
  50                 [Test]
  51                 [ExpectedException (typeof (ArgumentNullException))]
  52                 public void ConstructorNullSchemaContext ()
  53                 {
  54                         new XamlObjectReader ("foo", (XamlSchemaContext) null);
  55                 }
  56
  57                 [Test]
  58                 public void ConstructorNullSettings ()
  59                 {
  60                         new XamlObjectReader ("foo", (XamlObjectReaderSettings) null);
  61                 }
  62
  63                 [Test]
  64                 [ExpectedException (typeof (ArgumentNullException))]
  65                 public void ConstructorNullSchemaContext2 ()
  66                 {
  67                         new XamlObjectReader ("foo", null, new XamlObjectReaderSettings ());
  68                 }
  69
  70                 [Test]
  71                 public void ConstructorNullSettings2 ()
  72                 {
  73                         new XamlObjectReader ("foo", new XamlSchemaContext (null, null), null);
  74                 }
  75
  76                 [Test]
  77                 [ExpectedException (typeof (XamlObjectReaderException))]
  78                 public void ReadNonConstructible ()
  79                 {
  80                         // XamlType has no default constructor.
  81                         new XamlObjectReader (XamlLanguage.String);
  82                 }
  83
  84                 [Test]
  85                 [ExpectedException (typeof (XamlObjectReaderException))]
  86                 public void NonPublicType ()
  87                 {
  88                         new XamlObjectReader (new TestClass1 ());
  89                 }
  90
  91                 [Test]
  92                 [ExpectedException (typeof (XamlObjectReaderException))]
  93                 public void NestedType ()
  94                 {
  95                         new XamlObjectReader (new TestClass2 ());
  96                 }
  97
  98                 public class TestClass2
  99                 {
 100                 }
 101
 102                 [Test]
 103                 public void ConstructibleType ()
 104                 {
 105                         new XamlObjectReader (new TestClass3 ());
 106                 }
 107
 108                 // Based on Common tests
 109
 110                 [Test]
 111                 public void Read_String ()
 112                 {
 113                         var r = new XamlObjectReader ("foo");
 114                         Read_String (r);
 115                 }
 116
 117                 [Test]
 118                 public void WriteNullMemberAsObject ()
 119                 {
 120                         var r = new XamlObjectReader (new TestClass4 ());
 121                         WriteNullMemberAsObject (r, delegate {
 122                                 Assert.IsNull (r.Instance, "#x"); }
 123                                 );
 124                 }
 125
 126                 [Test]
 127                 public void StaticMember ()
 128                 {
 129                         var r = new XamlObjectReader (new TestClass5 ());
 130                         StaticMember (r);
 131                 }
 132
 133                 [Test]
 134                 public void Skip ()
 135                 {
 136                         var r = new XamlObjectReader ("Foo");
 137                         Skip (r);
 138                 }
 139
 140                 [Test]
 141                 public void Skip2 ()
 142                 {
 143                         var r = new XamlObjectReader ("Foo");
 144                         Skip2 (r);
 145                 }
 146
 147                 [Test]
 148                 public void Skip3 ()
 149                 {
 150                         var r = new XamlObjectReader (new ReadOnlyPropertyContainer () { Foo = "x" });
 151                         while (r.NodeType != XamlNodeType.StartMember)
 152                                 r.Read ();
 153                         r.Skip ();
 154                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#1");
 155                 }
 156
 157                 [Test]
 158                 public void Read_XmlDocument ()
 159                 {
 160                         var doc = new XmlDocument ();
 161                         doc.LoadXml ("<root xmlns='urn:foo'><elem attr='val' /></root>");
 162                         var r = new XamlObjectReader (doc);
 163                         Read_XmlDocument (r);
 164                 }
 165
 166                 [Test]
 167                 public void Read_NonPrimitive ()
 168                 {
 169                         var r = new XamlObjectReader (new TestClass3 ());
 170                         Read_NonPrimitive (r);
 171                 }
 172
 173                 [Test]
 174                 public void Read_Type ()
 175                 {
 176                         var r = new XamlObjectReader (typeof (int));
 177                         Read_TypeOrTypeExtension (r);
 178                 }
 179
 180                 [Test]
 181                 public void Read_TypeExtension ()
 182                 {
 183                         var tx = new TypeExtension (typeof (int));
 184                         var r = new XamlObjectReader (tx);
 185                         Read_TypeOrTypeExtension (r);
 186                 }
 187
 188                 void Read_TypeOrTypeExtension (XamlObjectReader r)
 189                 {
 190                         Read_TypeOrTypeExtension (r, delegate {
 191                                 Assert.IsTrue (r.Instance is TypeExtension, "#26");
 192                                 }, XamlLanguage.PositionalParameters);
 193                 }
 194
 195                 [Test]
 196                 public void Read_Type2 ()
 197                 {
 198                         var r = new XamlObjectReader (typeof (TestClass1));
 199                         Read_TypeOrTypeExtension2 (r);
 200                 }
 201
 202                 [Test]
 203                 public void Read_TypeExtension2 ()
 204                 {
 205                         var r = new XamlObjectReader (new TypeExtension (typeof (TestClass1)));
 206                         Read_TypeOrTypeExtension2 (r);
 207                 }
 208
 209                 void Read_TypeOrTypeExtension2 (XamlObjectReader r)
 210                 {
 211                         Read_TypeOrTypeExtension2 (r, delegate {
 212                                 Assert.IsTrue (r.Instance is TypeExtension, "#26");
 213                         }, XamlLanguage.PositionalParameters);
 214                 }
 215
 216                 [Test]
 217                 public void Read_Reference ()
 218                 {
 219                         var r = new XamlObjectReader (new Reference ("FooBar"));
 220                         Read_Reference (r);
 221                 }
 222
 223                 [Test]
 224                 public void Read_Null ()
 225                 {
 226                         var r = new XamlObjectReader (null);
 227                         Read_NullOrNullExtension (r, (object) null);
 228                 }
 229
 230                 [Test]
 231                 public void Read_NullExtension ()
 232                 {
 233                         var o = new NullExtension ();
 234                         var r = new XamlObjectReader (o);
 235                         Read_NullOrNullExtension (r, o);
 236                 }
 237
 238                 void Read_NullOrNullExtension (XamlObjectReader r, object instance)
 239                 {
 240                         Read_NullOrNullExtension (r, delegate {
 241                                 Assert.AreEqual (instance, r.Instance, "#26"); // null and NullExtension are different here.
 242                         });
 243                 }
 244
 245                 [Test]
 246                 public void Read_StaticExtension ()
 247                 {
 248                         var r = new XamlObjectReader (new StaticExtension ("FooBar"));
 249                         Read_StaticExtension (r, XamlLanguage.PositionalParameters);
 250                 }
 251
 252                 [Test]
 253                 public void Read_ListInt32 ()
 254                 {
 255                         var obj = new List<int> (new int [] {5, -3, int.MaxValue, 0});
 256                         Read_ListInt32 (obj);
 257                 }
 258
 259                 [Test]
 260                 public void Read_ListInt32_2 ()
 261                 {
 262                         var obj = new List<int> (new int [0]);
 263                         Read_ListInt32 (obj);
 264                 }
 265
 266                 void Read_ListInt32 (List<int> obj)
 267                 {
 268                         var r = new XamlObjectReader (obj);
 269                         Read_ListInt32 (r, delegate {
 270                                 Assert.AreEqual (obj, r.Instance, "#26");
 271                                 }, obj);
 272                 }
 273
 274                 [Test]
 275                 public void Read_ListType ()
 276                 {
 277                         var obj = new List<Type> (new Type [] {typeof (int), typeof (Dictionary<Type, XamlType>)}) { Capacity = 2 };
 278                         var r = new XamlObjectReader (obj);
 279                         Read_ListType (r, true);
 280                 }
 281
 282                 [Test]
 283                 public void Read_ListArray ()
 284                 {
 285                         var obj = new List<Array> (new Array [] { new int [] { 1,2,3}, new string [] { "foo", "bar", "baz" }}) { Capacity = 2 };
 286                         var r = new XamlObjectReader (obj);
 287                         Read_ListArray (r);
 288                 }
 289
 290                 [Test]
 291                 public void Read_ArrayList ()
 292                 {
 293                         var obj = new ArrayList (new int [] {5, -3, 0});
 294                         var r = new XamlObjectReader (obj);
 295                         Read_ArrayList (r);
 296                 }
 297
 298                 [Test]
 299                 public void Read_Array ()
 300                 {
 301                         var obj = new int [] {5, -3, 0};
 302                         var r = new XamlObjectReader (obj);
 303                         Read_ArrayOrArrayExtension (r, obj);
 304                 }
 305
 306                 [Test]
 307                 public void Read_ArrayExtension ()
 308                 {
 309                         var obj = new ArrayExtension (new int [] {5, -3, 0});
 310                         var r = new XamlObjectReader (obj);
 311                         Read_ArrayOrArrayExtension (r, obj);
 312                 }
 313
 314                 [Test]
 315                 public void Read_MyArrayExtension ()
 316                 {
 317                         var obj = new MyArrayExtension (new int [] {5, -3, 0});
 318                         var r = new XamlObjectReader (obj);
 319                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, obj, typeof (MyArrayExtension));
 320                 }
 321
 322                 void Read_ArrayOrArrayExtension (XamlObjectReader r, object instance)
 323                 {
 324                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, instance, typeof (ArrayExtension));
 325                 }
 326
 327                 void Read_ArrayOrArrayExtensionOrMyArrayExtension (XamlObjectReader r, object instance, Type extType)
 328                 {
 329                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, delegate {
 330                                 Assert.AreEqual (instance, r.Instance, "#26"); // different between Array and ArrayExtension. Also, different from Type and TypeExtension (Type returns TypeExtension, while Array remains to return Array)
 331                                 }, extType);
 332                 }
 333
 334                 [Test]
 335                 public void Read_ArrayExtension2 ()
 336                 {
 337                         var r = new XamlObjectReader (new ArrayExtension (typeof (int)));
 338                         Read_ArrayExtension2 (r);
 339                 }
 340
 341                 [Test]
 342                 public void Read_DateTime ()
 343                 {
 344                         var obj = new DateTime (2010, 4, 15);
 345                         var r = new XamlObjectReader (obj);
 346                         Read_CommonClrType (r, obj);
 347                         Assert.AreEqual ("2010-04-15", Read_Initialization (r, null), "#1");
 348                 }
 349
 350                 [Test]
 351                 public void Read_TimeSpan ()
 352                 {
 353                         Read_CommonXamlPrimitive (TimeSpan.FromMinutes (4));
 354                 }
 355
 356                 [Test]
 357                 public void Read_Uri ()
 358                 {
 359                         Read_CommonXamlPrimitive (new Uri ("urn:foo"));
 360                 }
 361
 362                 [Test]
 363                 public void Read_Guid ()
 364                 {
 365                         var obj = Guid.NewGuid ();
 366                         var r = new XamlObjectReader (obj);
 367                         Assert.IsNotNull (r.SchemaContext.GetXamlType (typeof (Guid)).TypeConverter, "premise#1");
 368                         Read_CommonClrType (r, obj);
 369                         Assert.AreEqual (obj.ToString (), Read_Initialization (r, null), "#1");
 370                 }
 371
 372                 [Test]
 373                 [ExpectedException (typeof (XamlObjectReaderException))]
 374                 [Category ("NotWorking")]
 375                 public void Read_XData ()
 376                 {
 377                         var r = new XamlObjectReader (new XData () {Text = "xdata text"}); // XmlReader implementation is not visible.
 378                         while (!r.IsEof)
 379                                 r.Read ();
 380                 }
 381
 382                 [Test]
 383                 [ExpectedException (typeof (XamlObjectReaderException))]
 384                 [Category ("NotWorking")]
 385                 public void Read_XDataWrapper ()
 386                 {
 387                         var obj = new XDataWrapper () { Markup = new XData () {Text = "<my_xdata/>" } };
 388                         var r = new XamlObjectReader (obj);
 389                         while (!r.IsEof)
 390                                 r.Read ();
 391                 }
 392
 393                 [Test]
 394                 public void ReadStandardTypes ()
 395                 {
 396                         SimpleReadStandardType (new ArrayExtension ());
 397                         SimpleReadStandardType (new NullExtension ());
 398                         SimpleReadStandardType (new PropertyDefinition ());
 399                         SimpleReadStandardType (new Reference ());
 400                         SimpleReadStandardType (new StaticExtension ());
 401                         SimpleReadStandardType (new TypeExtension ());
 402                 }
 403
 404                 void SimpleReadStandardType (object instance)
 405                 {
 406                         var r = new XamlObjectReader (instance);
 407                         while (!r.IsEof)
 408                                 r.Read ();
 409                 }
 410
 411                 [Test]
 412                 public void Read_CustomMarkupExtension ()
 413                 {
 414                         var r = new XamlObjectReader (new MyExtension () { Foo = typeof (int), Bar = "v2", Baz = "v7"});
 415                         Read_CustomMarkupExtension (r);
 416                 }
 417
 418                 [Test]
 419                 public void Read_CustomMarkupExtension2 ()
 420                 {
 421                         var r = new XamlObjectReader (new MyExtension2 () { Foo = typeof (int), Bar = "v2"});
 422                         Read_CustomMarkupExtension2 (r);
 423                 }
 424
 425                 [Test]
 426                 public void Read_CustomMarkupExtension3 ()
 427                 {
 428                         var r = new XamlObjectReader (new MyExtension3 () { Foo = typeof (int), Bar = "v2"});
 429                         Read_CustomMarkupExtension3 (r);
 430                 }
 431
 432                 [Test]
 433                 public void Read_CustomMarkupExtension4 ()
 434                 {
 435                         var r = new XamlObjectReader (new MyExtension4 () { Foo = typeof (int), Bar = "v2"});
 436                         Read_CustomMarkupExtension4 (r);
 437                 }
 438
 439                 [Test]
 440                 public void Read_CustomMarkupExtension5 ()
 441                 {
 442                         // This cannot be written to XamlXmlWriter though...
 443
 444                         var r = new XamlObjectReader (new MyExtension5 ("foo", "bar"));
 445                         Read_CustomMarkupExtension5 (r);
 446                 }
 447
 448                 [Test]
 449                 public void Read_CustomMarkupExtension6 ()
 450                 {
 451                         var r = new XamlObjectReader (new MyExtension6 ("foo"));
 452                         Read_CustomMarkupExtension6 (r);
 453                 }
 454
 455                 [Test]
 456                 public void Read_ArgumentAttributed ()
 457                 {
 458                         var obj = new ArgumentAttributed ("foo", "bar");
 459                         var r = new XamlObjectReader (obj);
 460                         Read_ArgumentAttributed (r, obj);
 461                 }
 462
 463                 [Test]
 464                 public void Read_Dictionary ()
 465                 {
 466                         var obj = new Dictionary<string,object> ();
 467                         obj ["Foo"] = 5.0;
 468                         obj ["Bar"] = -6.5;
 469                         var r = new XamlObjectReader (obj);
 470                         Read_Dictionary (r);
 471                 }
 472
 473                 [Test]
 474                 public void Read_Dictionary2 ()
 475                 {
 476                         var obj = new Dictionary<string,Type> ();
 477                         obj ["Foo"] = typeof (int);
 478                         obj ["Bar"] = typeof (Dictionary<Type,XamlType>);
 479                         var r = new XamlObjectReader (obj);
 480                         Read_Dictionary2 (r, XamlLanguage.PositionalParameters);
 481                 }
 482
 483                 [Test]
 484                 public void PositionalParameters1 ()
 485                 {
 486                         // Note: this can be read, but cannot be written to XML.
 487                         var obj = new PositionalParametersClass1 ("foo", 5);
 488                         var r = new XamlObjectReader (obj);
 489                         PositionalParameters1 (r);
 490                 }
 491
 492                 [Test]
 493                 public void PositionalParameters2 ()
 494                 {
 495                         var obj = new PositionalParametersWrapper ("foo", 5);
 496                         var r = new XamlObjectReader (obj);
 497                         PositionalParameters2 (r);
 498                 }
 499
 500                 [Test]
 501                 public void ComplexPositionalParameters ()
 502                 {
 503                         var obj = new ComplexPositionalParameterWrapper () { Param = new ComplexPositionalParameterClass (new ComplexPositionalParameterValue () { Foo = "foo" })};
 504                         var r = new XamlObjectReader (obj);
 505                         ComplexPositionalParameters (r);
 506                 }
 507
 508                 [Test]
 509                 public void Read_ListWrapper ()
 510                 {
 511                         var obj = new ListWrapper (new List<int> (new int [] {5, -3, 0}));
 512                         var r = new XamlObjectReader (obj);
 513                         Read_ListWrapper (r);
 514                 }
 515
 516                 [Test]
 517                 public void Read_ListWrapper2 () // read-write list member.
 518                 {
 519                         var obj = new ListWrapper2 (new List<int> (new int [] {5, -3, 0}));
 520                         var r = new XamlObjectReader (obj);
 521                         Read_ListWrapper2 (r);
 522                 }
 523
 524                 [Test]
 525                 public void Read_ContentIncluded ()
 526                 {
 527                         var obj = new ContentIncludedClass () { Content = "foo" };
 528                         var r = new XamlObjectReader (obj);
 529                         Read_ContentIncluded (r);
 530                 }
 531
 532                 [Test]
 533                 public void Read_PropertyDefinition ()
 534                 {
 535                         var obj = new PropertyDefinition () { Modifier = "protected", Name = "foo", Type = XamlLanguage.String };
 536                         var r = new XamlObjectReader (obj);
 537                         Read_PropertyDefinition (r);
 538                 }
 539
 540                 [Test]
 541                 public void Read_StaticExtensionWrapper ()
 542                 {
 543                         var obj = new StaticExtensionWrapper () { Param = new StaticExtension ("StaticExtensionWrapper.Foo") };
 544                         var r = new XamlObjectReader (obj);
 545                         Read_StaticExtensionWrapper (r);
 546                 }
 547
 548                 [Test]
 549                 public void Read_TypeExtensionWrapper ()
 550                 {
 551                         var obj = new TypeExtensionWrapper () { Param = new TypeExtension ("Foo") };
 552                         var r = new XamlObjectReader (obj);
 553                         Read_TypeExtensionWrapper (r);
 554                 }
 555
 556                 [Test]
 557                 public void Read_EventContainer ()
 558                 {
 559                         var obj = new EventContainer ();
 560                         obj.Run += delegate { Console.Error.WriteLine ("done"); };
 561                         var xr = new XamlObjectReader (obj);
 562                         Read_EventContainer (xr);
 563                 }
 564
 565                 [Test]
 566                 public void Read_NamedItems ()
 567                 {
 568                         // foo
 569                         // - bar
 570                         // -- foo
 571                         // - baz
 572                         var obj = new NamedItem ("foo");
 573                         var obj2 = new NamedItem ("bar");
 574                         obj.References.Add (obj2);
 575                         obj.References.Add (new NamedItem ("baz"));
 576                         obj2.References.Add (obj);
 577
 578                         var xr = new XamlObjectReader (obj);
 579                         Read_NamedItems (xr, true);
 580                 }
 581
 582                 [Test]
 583                 public void Read_NamedItems2 ()
 584                 {
 585                         // i1
 586                         // - i2
 587                         // -- i3
 588                         // - i4
 589                         // -- i3
 590                         var obj = new NamedItem2 ("i1");
 591                         var obj2 = new NamedItem2 ("i2");
 592                         var obj3 = new NamedItem2 ("i3");
 593                         var obj4 = new NamedItem2 ("i4");
 594                         obj.References.Add (obj2);
 595                         obj.References.Add (obj4);
 596                         obj2.References.Add (obj3);
 597                         obj4.References.Add (obj3);
 598
 599                         var xr = new XamlObjectReader (obj);
 600                         Read_NamedItems2 (xr, true);
 601                 }
 602
 603                 [Test]
 604                 public void Read_XmlSerializableWrapper ()
 605                 {
 606                         var obj = new XmlSerializableWrapper (new XmlSerializable ("<root/>"));
 607                         var xr = new XamlObjectReader (obj);
 608                         Read_XmlSerializableWrapper (xr, true);
 609                 }
 610
 611                 [Test] // If it is root, it is not serialized as IXmlSerializable.
 612                 public void Read_XmlSerializable ()
 613                 {
 614                         var obj = new XmlSerializable ("<root/>");
 615                         var xr = new XamlObjectReader (obj);
 616                         Read_XmlSerializable (xr);
 617                 }
 618
 619                 [Test] // List contents are (sort of) treated as top-level too, so it is not serialized as IXmlSerializable(!)
 620                 public void Read_ListXmlSerializable ()
 621                 {
 622                         var obj = new List<XmlSerializable> ();
 623                         obj.Add (new XmlSerializable ("<root/>"));
 624                         var xr = new XamlObjectReader (obj);
 625                         Read_ListXmlSerializable (xr);
 626                 }
 627
 628                 [Test]
 629                 public void Read_AttachedProperty ()
 630                 {
 631                         var obj = new AttachedWrapper ();
 632                         Attachable.SetFoo (obj, "x");
 633                         Attachable.SetFoo (obj.Value, "y");
 634                         try {
 635                                 var xr = new XamlObjectReader (obj);
 636                                 Read_AttachedProperty (xr);
 637                         } finally {
 638                                 Attachable.SetFoo (obj, null);
 639                                 Attachable.SetFoo (obj.Value, null);
 640                         }
 641                 }
 642
 643                 [Test]
 644                 [Ignore ("Foo does not work as attached properties in this test yet")]
 645                 public void Read_AttachedProperty2 ()
 646                 {
 647                         var obj = new AttachedWrapper2 ();
 648                         AttachedWrapper2.SetFoo (obj, "x");
 649                         AttachedWrapper2.SetFoo (obj.Value, "y");
 650                         try {
 651                                 var xr = new XamlObjectReader (obj);
 652 //while (xr.Read ()) Console.Error.WriteLine ("{0} {1} {2} {3}", xr.NodeType, xr.Type, xr.Member, xr.Value);
 653                         } finally {
 654                                 AttachedWrapper2.SetFoo (obj, null);
 655                                 AttachedWrapper2.SetFoo (obj.Value, null);
 656                         }
 657                 }
 658
 659                 [Test]
 660                 public void Read_AbstractContainer ()
 661                 {
 662                         var obj = new AbstractContainer () { Value2 = new DerivedObject () { Foo = "x" } };
 663                         var xr = new XamlObjectReader (obj);
 664                         while (!xr.IsEof)
 665                                 xr.Read ();
 666                 }
 667
 668                 [Test]
 669                 public void Read_ReadOnlyPropertyContainer ()
 670                 {
 671                         var obj = new ReadOnlyPropertyContainer () { Foo = "x" };
 672                         var xr = new XamlObjectReader (obj);
 673                         var xt = xr.SchemaContext.GetXamlType (obj.GetType ());
 674                         while (xr.Read ())
 675                                 if (xr.NodeType == XamlNodeType.StartMember)
 676                                         break;
 677                         Assert.AreEqual (xt.GetMember ("Foo"), xr.Member, "#1");
 678                         while (!xr.IsEof)
 679                                 xr.Read ();
 680                 }
 681
 682                 [Test]
 683                 public void Read_TypeConverterOnListMember ()
 684                 {
 685                         var obj = new SecondTest.TypeOtherAssembly ();
 686                         obj.Values.AddRange (new uint? [] {1, 2, 3});
 687                         var xr = new XamlObjectReader (obj);
 688                         Read_TypeConverterOnListMember (xr);
 689                 }
 690
 691                 [Test]
 692                 public void Read_EnumContainer ()
 693                 {
 694                         var obj = new EnumContainer () { EnumProperty = EnumValueType.Two };
 695                         var xr = new XamlObjectReader (obj);
 696                         Read_EnumContainer (xr);
 697                 }
 698
 699                 [Test]
 700                 public void Read_CollectionContentProperty ()
 701                 {
 702                         var obj = new CollectionContentProperty ();
 703                         for (int i = 0; i < 4; i++)
 704                                 obj.ListOfItems.Add (new SimpleClass ());
 705                         var xr = new XamlObjectReader (obj);
 706                         Read_CollectionContentProperty (xr, false);
 707                 }
 708
 709                 [Test]
 710                 public void Read_CollectionContentPropertyX ()
 711                 {
 712                         var obj = new CollectionContentPropertyX ();
 713                         var l = new List<object> ();
 714                         obj.ListOfItems.Add (l);
 715                         for (int i = 0; i < 4; i++)
 716                                 l.Add (new SimpleClass ());
 717                         var xr = new XamlObjectReader (obj);
 718                         Read_CollectionContentPropertyX (xr, false);
 719                 }
 720
 721                 [Test]
 722                 [Category ("NotWorking")] // only member ordering difference, maybe.
 723                 public void Read_AmbientPropertyContainer ()
 724                 {
 725                         var obj = new SecondTest.ResourcesDict ();
 726                         var t1 = new SecondTest.TestObject ();
 727                         obj.Add ("TestDictItem", t1);
 728                         var t2 = new SecondTest.TestObject ();
 729                         t2.TestProperty = t1;
 730                         obj.Add ("okay", t2);
 731                         var xr = new XamlObjectReader (obj);
 732                         Read_AmbientPropertyContainer (xr, false);
 733                 }
 734
 735                 [Test]
 736                 [Category ("NotWorking")] // only member ordering difference, maybe.
 737                 public void Read_AmbientPropertyContainer2 ()
 738                 {
 739                         var obj = new SecondTest.ResourcesDict ();
 740                         var t1 = new SecondTest.TestObject ();
 741                         obj.Add ("TestDictItem", t1);
 742                         obj.Add ("okay", new SecondTest.ResourceExtension (t1));
 743                         var xr = new XamlObjectReader (obj);
 744                         Read_AmbientPropertyContainer (xr, true);
 745                 }
 746
 747                 [Test]
 748                 public void Read_NullableContainer ()
 749                 {
 750                         var obj = new NullableContainer () { TestProp = 5 };
 751                         var xr = new XamlObjectReader (obj);
 752                         Read_NullableContainer (xr);
 753                 }
 754         }
 755 }