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 // Some test result remarks:
  39 // - TypeExtension: [ConstructorArgument] -> PositionalParameters
  40 // - StaticExtension: almost identical to TypeExtension
  41 // - Reference: [ConstructorArgument], [ContentProperty] -> only ordinal member.
  42 // - ArrayExtension: [ConstrutorArgument], [ContentProperty] -> no PositionalParameters, Items.
  43 // - NullExtension: no member.
  44 // - MyExtension: [ConstructorArgument] -> only ordinal members...hmm?
  45
  46 namespace MonoTests.System.Xaml
  47 {
  48         [TestFixture]
  49         public partial class XamlObjectReaderTest : XamlReaderTestBase
  50         {
  51                 [Test]
  52                 public void ConstructorNullObject ()
  53                 {
  54                         // allowed.
  55                         new XamlObjectReader (null);
  56                 }
  57
  58                 [Test]
  59                 [ExpectedException (typeof (ArgumentNullException))]
  60                 public void ConstructorNullSchemaContext ()
  61                 {
  62                         new XamlObjectReader ("foo", (XamlSchemaContext) null);
  63                 }
  64
  65                 [Test]
  66                 public void ConstructorNullSettings ()
  67                 {
  68                         new XamlObjectReader ("foo", (XamlObjectReaderSettings) null);
  69                 }
  70
  71                 [Test]
  72                 [ExpectedException (typeof (ArgumentNullException))]
  73                 public void ConstructorNullSchemaContext2 ()
  74                 {
  75                         new XamlObjectReader ("foo", null, new XamlObjectReaderSettings ());
  76                 }
  77
  78                 [Test]
  79                 public void ConstructorNullSettings2 ()
  80                 {
  81                         new XamlObjectReader ("foo", new XamlSchemaContext (null, null), null);
  82                 }
  83
  84                 [Test]
  85                 [ExpectedException (typeof (XamlObjectReaderException))]
  86                 public void ReadNonConstructible ()
  87                 {
  88                         // XamlType has no default constructor.
  89                         new XamlObjectReader (XamlLanguage.String);
  90                 }
  91
  92                 [Test]
  93                 [ExpectedException (typeof (XamlObjectReaderException))]
  94                 public void NonPublicType ()
  95                 {
  96                         new XamlObjectReader (new TestClass1 ());
  97                 }
  98
  99                 [Test]
 100                 [ExpectedException (typeof (XamlObjectReaderException))]
 101                 public void NestedType ()
 102                 {
 103                         new XamlObjectReader (new TestClass2 ());
 104                 }
 105
 106                 public class TestClass2
 107                 {
 108                 }
 109
 110                 [Test]
 111                 public void ConstructibleType ()
 112                 {
 113                         new XamlObjectReader (new TestClass3 ());
 114                 }
 115         }
 116
 117         public partial class XamlReaderTestBase
 118         {
 119                 protected void Read_String (XamlReader r)
 120                 {
 121                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 122                         Assert.IsNull (r.Member, "#2");
 123                         Assert.IsNull (r.Namespace, "#3");
 124                         Assert.IsNull (r.Member, "#4");
 125                         Assert.IsNull (r.Type, "#5");
 126                         Assert.IsNull (r.Value, "#6");
 127
 128                         Assert.IsTrue (r.Read (), "#11");
 129                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 130                         Assert.IsNotNull (r.Namespace, "#13");
 131                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 132                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 133
 134                         Assert.IsTrue (r.Read (), "#21");
 135                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 136                         Assert.IsNotNull (r.Type, "#23");
 137                         Assert.AreEqual (new XamlType (typeof (string), r.SchemaContext), r.Type, "#23-2");
 138                         Assert.IsNull (r.Namespace, "#25");
 139
 140                         if (r is XamlXmlReader)
 141                                 ReadBase (r);
 142
 143                         Assert.IsTrue (r.Read (), "#31");
 144                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 145                         Assert.IsNotNull (r.Member, "#33");
 146                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#33-2");
 147                         Assert.IsNull (r.Type, "#34");
 148
 149                         Assert.IsTrue (r.Read (), "#41");
 150                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 151                         Assert.AreEqual ("foo", r.Value, "#43");
 152                         Assert.IsNull (r.Member, "#44");
 153
 154                         Assert.IsTrue (r.Read (), "#51");
 155                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 156                         Assert.IsNull (r.Type, "#53");
 157                         Assert.IsNull (r.Member, "#54");
 158
 159                         Assert.IsTrue (r.Read (), "#61");
 160                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 161                         Assert.IsNull (r.Type, "#63");
 162
 163                         Assert.IsFalse (r.Read (), "#71");
 164                         Assert.IsTrue (r.IsEof, "#72");
 165                 }
 166
 167                 protected void WriteNullMemberAsObject (XamlReader r, Action validateNullInstance)
 168                 {
 169                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 170                         Assert.IsTrue (r.Read (), "#6");
 171                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
 172                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#7-2");
 173                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "#7-3");
 174
 175                         Assert.IsTrue (r.Read (), "#11");
 176                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 177                         Assert.AreEqual ("x", r.Namespace.Prefix, "#12-2");
 178                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#12-3");
 179
 180                         Assert.IsTrue (r.Read (), "#16");
 181                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#17");
 182                         var xt = new XamlType (typeof (TestClass4), r.SchemaContext);
 183                         Assert.AreEqual (xt, r.Type, "#17-2");
 184 //                      Assert.IsTrue (r.Instance is TestClass4, "#17-3");
 185                         Assert.AreEqual (2, xt.GetAllMembers ().Count, "#17-4");
 186
 187                         if (r is XamlXmlReader)
 188                                 ReadBase (r);
 189
 190                         Assert.IsTrue (r.Read (), "#21");
 191                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#22");
 192                         Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#22-2");
 193
 194                         Assert.IsTrue (r.Read (), "#26");
 195                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#27");
 196                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#27-2");
 197                         if (validateNullInstance != null)
 198                                 validateNullInstance ();
 199
 200                         Assert.IsTrue (r.Read (), "#31");
 201                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#32");
 202
 203                         Assert.IsTrue (r.Read (), "#36");
 204                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#37");
 205
 206                         Assert.IsTrue (r.Read (), "#41");
 207                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#42");
 208                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#42-2");
 209
 210                         Assert.IsTrue (r.Read (), "#43");
 211                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#43-2");
 212                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#43-3");
 213                         if (validateNullInstance != null)
 214                                 validateNullInstance ();
 215
 216                         Assert.IsTrue (r.Read (), "#44");
 217                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#44-2");
 218
 219                         Assert.IsTrue (r.Read (), "#46");
 220                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#47");
 221
 222                         Assert.IsTrue (r.Read (), "#51");
 223                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#52");
 224
 225                         Assert.IsFalse (r.Read (), "#56");
 226                         Assert.IsTrue (r.IsEof, "#57");
 227                 }
 228
 229                 protected void StaticMember (XamlReader r)
 230                 {
 231                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 232                         Assert.IsTrue (r.Read (), "#6");
 233                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
 234                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#7-2");
 235                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "#7-3");
 236
 237                         Assert.IsTrue (r.Read (), "#11");
 238                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 239                         Assert.AreEqual ("x", r.Namespace.Prefix, "#12-2");
 240                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#12-3");
 241
 242                         Assert.IsTrue (r.Read (), "#16");
 243                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#17");
 244                         var xt = new XamlType (typeof (TestClass5), r.SchemaContext);
 245                         Assert.AreEqual (xt, r.Type, "#17-2");
 246 //                      Assert.IsTrue (r.Instance is TestClass5, "#17-3");
 247                         Assert.AreEqual (2, xt.GetAllMembers ().Count, "#17-4");
 248                         Assert.IsTrue (xt.GetAllMembers ().Any (xm => xm.Name == "Bar"), "#17-5");
 249                         Assert.IsTrue (xt.GetAllMembers ().Any (xm => xm.Name == "Baz"), "#17-6");
 250
 251                         if (r is XamlXmlReader)
 252                                 ReadBase (r);
 253
 254                         Assert.IsTrue (r.Read (), "#21");
 255                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#22");
 256                         Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#22-2");
 257
 258                         Assert.IsTrue (r.Read (), "#26");
 259                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#27");
 260                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#27-2");
 261 //                      Assert.IsNull (r.Instance, "#27-3");
 262
 263                         Assert.IsTrue (r.Read (), "#31");
 264                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#32");
 265
 266                         Assert.IsTrue (r.Read (), "#36");
 267                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#37");
 268                         // static Foo is not included in GetAllXembers() return value.
 269                         // ReadOnly is not included in GetAllMembers() return value neither.
 270                         // nonpublic Baz is a member, but does not appear in the reader.
 271
 272                         Assert.IsTrue (r.Read (), "#51");
 273                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#52");
 274
 275                         Assert.IsFalse (r.Read (), "#56");
 276                         Assert.IsTrue (r.IsEof, "#57");
 277                 }
 278
 279                 protected void Skip (XamlReader r)
 280                 {
 281                         r.Skip ();
 282                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 283                         r.Skip ();
 284                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2");
 285                         r.Skip ();
 286                         Assert.IsTrue (r.IsEof, "#3");
 287                 }
 288
 289                 protected void Skip2 (XamlReader r)
 290                 {
 291                         r.Read (); // NamespaceDeclaration
 292                         r.Read (); // Type
 293                         if (r is XamlXmlReader)
 294                                 ReadBase (r);
 295                         r.Read (); // Member (Initialization)
 296                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#1");
 297                         r.Skip ();
 298                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#2");
 299                         r.Skip ();
 300                         Assert.IsTrue (r.IsEof, "#3");
 301                 }
 302
 303                 protected void Read_XmlDocument (XamlReader r)
 304                 {
 305                         for (int i = 0; i < 3; i++) {
 306                                 r.Read ();
 307                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-" + i);
 308                         }
 309                         r.Read ();
 310
 311                         Assert.AreEqual (new XamlType (typeof (XmlDocument), r.SchemaContext), r.Type, "#2");
 312                         r.Read ();
 313                         var l = new List<XamlMember> ();
 314                         while (r.NodeType == XamlNodeType.StartMember) {
 315                         // It depends on XmlDocument's implenentation details. It fails on mono only because XmlDocument.SchemaInfo overrides both getter and setter.
 316                         //for (int i = 0; i < 5; i++) {
 317                         //      Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-" + i);
 318                                 l.Add (r.Member);
 319                                 r.Skip ();
 320                         }
 321                         Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "Value"), "#4-1");
 322                         Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "InnerXml"), "#4-2");
 323                         Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "Prefix"), "#4-3");
 324                         Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "PreserveWhitespace"), "#4-4");
 325                         Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "Schemas"), "#4-5");
 326                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#5");
 327                         Assert.IsFalse (r.Read (), "#6");
 328                 }
 329
 330                 protected void Read_NonPrimitive (XamlReader r)
 331                 {
 332                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 333                         Assert.IsTrue (r.Read (), "#6");
 334                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
 335                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#7-2");
 336                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "#7-3");
 337
 338                         Assert.IsTrue (r.Read (), "#11");
 339                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 340                         Assert.AreEqual ("x", r.Namespace.Prefix, "#12-2");
 341                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#12-3");
 342
 343                         Assert.IsTrue (r.Read (), "#16");
 344                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#17");
 345                         var xt = new XamlType (typeof (TestClass3), r.SchemaContext);
 346                         Assert.AreEqual (xt, r.Type, "#17-2");
 347 //                      Assert.IsTrue (r.Instance is TestClass3, "#17-3");
 348
 349                         if (r is XamlXmlReader)
 350                                 ReadBase (r);
 351
 352                         Assert.IsTrue (r.Read (), "#21");
 353                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#22");
 354                         Assert.AreEqual (xt.GetMember ("Nested"), r.Member, "#22-2");
 355
 356                         Assert.IsTrue (r.Read (), "#26");
 357                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#27");
 358                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#27-2");
 359 //                      Assert.IsNull (r.Instance, "#27-3");
 360
 361                         Assert.IsTrue (r.Read (), "#31");
 362                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#32");
 363
 364                         Assert.IsTrue (r.Read (), "#36");
 365                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#37");
 366
 367                         Assert.IsTrue (r.Read (), "#41");
 368                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#42");
 369
 370                         Assert.IsFalse (r.Read (), "#46");
 371                         Assert.IsTrue (r.IsEof, "#47");
 372                 }
 373
 374                 protected void Read_TypeOrTypeExtension (XamlReader r, Action validateInstance, XamlMember ctorArgMember)
 375                 {
 376                         Assert.IsTrue (r.Read (), "#11");
 377                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 378                         Assert.IsNotNull (r.Namespace, "#13");
 379                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 380                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 381 //                      Assert.IsNull (r.Instance, "#14");
 382
 383                         Assert.IsTrue (r.Read (), "#21");
 384                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 385                         Assert.IsNotNull (r.Type, "#23");
 386                         Assert.AreEqual (new XamlType (typeof (TypeExtension), r.SchemaContext), r.Type, "#23-2");
 387                         Assert.IsNull (r.Namespace, "#25");
 388                         if (validateInstance != null)
 389                                 validateInstance ();
 390
 391                         if (r is XamlXmlReader)
 392                                 ReadBase (r);
 393
 394                         Assert.IsTrue (r.Read (), "#31");
 395                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 396                         Assert.IsNotNull (r.Member, "#33");
 397                         Assert.AreEqual (ctorArgMember, r.Member, "#33-2");
 398                         Assert.IsNull (r.Type, "#34");
 399 //                      Assert.IsNull (r.Instance, "#35");
 400
 401                         Assert.IsTrue (r.Read (), "#41");
 402                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 403                         Assert.IsNotNull (r.Value, "#43");
 404                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 405                         Assert.IsNull (r.Member, "#44");
 406 //                      Assert.IsNull (r.Instance, "#45");
 407
 408                         Assert.IsTrue (r.Read (), "#51");
 409                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 410                         Assert.IsNull (r.Type, "#53");
 411                         Assert.IsNull (r.Member, "#54");
 412 //                      Assert.IsNull (r.Instance, "#55");
 413
 414                         Assert.IsTrue (r.Read (), "#61");
 415                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 416                         Assert.IsNull (r.Type, "#63");
 417
 418                         Assert.IsFalse (r.Read (), "#71");
 419                         Assert.IsTrue (r.IsEof, "#72");
 420                 }
 421
 422                 protected void Read_TypeOrTypeExtension2 (XamlReader r, Action validateInstance, XamlMember ctorArgMember)
 423                 {
 424                         Assert.IsTrue (r.Read (), "#11");
 425                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 426
 427                         var defns = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name;
 428
 429                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#13-2");
 430                         Assert.AreEqual (defns, r.Namespace.Namespace, "#13-3:" + r.Namespace.Prefix);
 431
 432                         Assert.IsTrue (r.Read (), "#16");
 433                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#17");
 434                         Assert.IsNotNull (r.Namespace, "#18");
 435                         Assert.AreEqual ("x", r.Namespace.Prefix, "#18-2");
 436                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#18-3:" + r.Namespace.Prefix);
 437
 438                         Assert.IsTrue (r.Read (), "#21");
 439                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 440                         Assert.AreEqual (new XamlType (typeof (TypeExtension), r.SchemaContext), r.Type, "#23-2");
 441                         if (validateInstance != null)
 442                                 validateInstance ();
 443
 444                         if (r is XamlXmlReader)
 445                                 ReadBase (r);
 446
 447                         Assert.IsTrue (r.Read (), "#31");
 448                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 449                         Assert.AreEqual (ctorArgMember, r.Member, "#33-2");
 450
 451                         Assert.IsTrue (r.Read (), "#41");
 452                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 453                         Assert.AreEqual ("TestClass1", r.Value, "#43-2");
 454
 455                         Assert.IsTrue (r.Read (), "#51");
 456                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 457
 458                         Assert.IsTrue (r.Read (), "#61");
 459                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 460
 461                         Assert.IsFalse (r.Read (), "#71");
 462                         Assert.IsTrue (r.IsEof, "#72");
 463                 }
 464
 465                 protected void Read_Reference (XamlReader r)
 466                 {
 467                         Assert.IsTrue (r.Read (), "#11");
 468                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 469                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 470                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 471
 472                         Assert.IsTrue (r.Read (), "#21");
 473                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 474                         var xt = new XamlType (typeof (Reference), r.SchemaContext);
 475                         Assert.AreEqual (xt, r.Type, "#23-2");
 476 //                      Assert.IsTrue (r.Instance is Reference, "#26");
 477
 478                         if (r is XamlXmlReader)
 479                                 ReadBase (r);
 480
 481                         Assert.IsTrue (r.Read (), "#31");
 482                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 483                         // unlike TypeExtension there is no PositionalParameters.
 484                         Assert.AreEqual (xt.GetMember ("Name"), r.Member, "#33-2");
 485
 486                         // It is a ContentProperty (besides [ConstructorArgument])
 487                         Assert.IsTrue (r.Read (), "#41");
 488                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 489                         Assert.AreEqual ("FooBar", r.Value, "#43-2");
 490
 491                         Assert.IsTrue (r.Read (), "#51");
 492                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 493
 494                         Assert.IsTrue (r.Read (), "#61");
 495                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 496
 497                         Assert.IsFalse (r.Read (), "#71");
 498                         Assert.IsTrue (r.IsEof, "#72");
 499                 }
 500
 501                 protected void Read_NullOrNullExtension (XamlReader r, Action validateInstance)
 502                 {
 503                         Assert.IsTrue (r.Read (), "#11");
 504                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 505                         Assert.IsNotNull (r.Namespace, "#13");
 506                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 507                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 508 //                      Assert.IsNull (r.Instance, "#14");
 509
 510                         Assert.IsTrue (r.Read (), "#21");
 511                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 512                         Assert.AreEqual (new XamlType (typeof (NullExtension), r.SchemaContext), r.Type, "#23-2");
 513                         if (validateInstance != null)
 514                                 validateInstance ();
 515
 516                         if (r is XamlXmlReader)
 517                                 ReadBase (r);
 518
 519                         Assert.IsTrue (r.Read (), "#61");
 520                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 521
 522                         Assert.IsFalse (r.Read (), "#71");
 523                         Assert.IsTrue (r.IsEof, "#72");
 524                 }
 525
 526                 // almost identical to TypeExtension (only type/instance difference)
 527                 protected void Read_StaticExtension (XamlReader r, XamlMember ctorArgMember)
 528                 {
 529                         Assert.IsTrue (r.Read (), "#11");
 530                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 531                         Assert.IsNotNull (r.Namespace, "#13");
 532                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 533                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 534 //                      Assert.IsNull (r.Instance, "#14");
 535
 536                         Assert.IsTrue (r.Read (), "#21");
 537                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 538                         Assert.AreEqual (new XamlType (typeof (StaticExtension), r.SchemaContext), r.Type, "#23-2");
 539 //                      Assert.IsTrue (r.Instance is StaticExtension, "#26");
 540
 541                         if (r is XamlXmlReader)
 542                                 ReadBase (r);
 543
 544                         Assert.IsTrue (r.Read (), "#31");
 545                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 546                         Assert.AreEqual (ctorArgMember, r.Member, "#33-2");
 547
 548                         Assert.IsTrue (r.Read (), "#41");
 549                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 550                         Assert.AreEqual ("FooBar", r.Value, "#43-2");
 551
 552                         Assert.IsTrue (r.Read (), "#51");
 553                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 554
 555                         Assert.IsTrue (r.Read (), "#61");
 556                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 557
 558                         Assert.IsFalse (r.Read (), "#71");
 559                         Assert.IsTrue (r.IsEof, "#72");
 560                 }
 561
 562                 protected void Read_ListInt32 (XamlReader r, Action validateInstance, List<int> obj)
 563                 {
 564                         Assert.IsTrue (r.Read (), "ns#1-1");
 565                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
 566
 567                         var defns = "clr-namespace:System.Collections.Generic;assembly=mscorlib";
 568
 569                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3");
 570                         Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4");
 571
 572                         Assert.IsTrue (r.Read (), "#11");
 573                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 574                         Assert.IsNotNull (r.Namespace, "#13");
 575                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 576                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 577
 578                         Assert.IsTrue (r.Read (), "#21");
 579                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 580                         var xt = new XamlType (typeof (List<int>), r.SchemaContext);
 581                         Assert.AreEqual (xt, r.Type, "#23");
 582                         Assert.IsTrue (xt.IsCollection, "#27");
 583                         if (validateInstance != null)
 584                                 validateInstance ();
 585
 586                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 587
 588                         if (r is XamlXmlReader)
 589                                 ReadBase (r);
 590
 591                         Assert.IsTrue (r.Read (), "#31");
 592                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 593                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
 594
 595                         Assert.IsTrue (r.Read (), "#41");
 596                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 597                         // The value is implementation details, not testable.
 598                         //Assert.AreEqual ("3", r.Value, "#43");
 599
 600                         Assert.IsTrue (r.Read (), "#51");
 601                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 602
 603                         if (obj.Count > 0) { // only when items exist.
 604
 605                         Assert.IsTrue (r.Read (), "#72");
 606                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 607                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 608
 609                         string [] values = {"5", "-3", "2147483647", "0"};
 610                         for (int i = 0; i < 4; i++) {
 611                                 Assert.IsTrue (r.Read (), i + "#73");
 612                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 613                                 Assert.IsTrue (r.Read (), i + "#74");
 614                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 615                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 616                                 Assert.IsTrue (r.Read (), i + "#75");
 617                                 Assert.IsNotNull (r.Value, i + "#75-2");
 618                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 619                                 Assert.IsTrue (r.Read (), i + "#74");
 620                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 621                                 Assert.IsTrue (r.Read (), i + "#75");
 622                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 623                         }
 624
 625                         Assert.IsTrue (r.Read (), "#81");
 626                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 627
 628                         } // end of "if count > 0".
 629
 630                         Assert.IsTrue (r.Read (), "#87");
 631                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88");
 632
 633                         Assert.IsFalse (r.Read (), "#89");
 634                 }
 635
 636                 protected void Read_ArrayList (XamlReader r)
 637                 {
 638                         Assert.IsTrue (r.Read (), "ns#1-1");
 639                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
 640
 641                         var defns = "clr-namespace:System.Collections;assembly=mscorlib";
 642
 643                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3");
 644                         Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4");
 645
 646                         Assert.IsTrue (r.Read (), "#11");
 647                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 648                         Assert.IsNotNull (r.Namespace, "#13");
 649                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 650                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 651
 652                         Assert.IsTrue (r.Read (), "#21");
 653                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 654                         var xt = new XamlType (typeof (ArrayList), r.SchemaContext);
 655                         Assert.AreEqual (xt, r.Type, "#23");
 656 //                      Assert.AreEqual (obj, r.Instance, "#26");
 657                         Assert.IsTrue (xt.IsCollection, "#27");
 658
 659                         if (r is XamlXmlReader)
 660                                 ReadBase (r);
 661
 662                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 663
 664                         Assert.IsTrue (r.Read (), "#31");
 665                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 666                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
 667
 668                         Assert.IsTrue (r.Read (), "#41");
 669                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 670                         // The value is implementation details, not testable.
 671                         //Assert.AreEqual ("3", r.Value, "#43");
 672
 673                         Assert.IsTrue (r.Read (), "#51");
 674                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 675
 676                         Assert.IsTrue (r.Read (), "#72");
 677                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 678                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 679
 680                         string [] values = {"5", "-3", "0"};
 681                         for (int i = 0; i < 3; i++) {
 682                                 Assert.IsTrue (r.Read (), i + "#73");
 683                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 684                                 Assert.IsTrue (r.Read (), i + "#74");
 685                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 686                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 687                                 Assert.IsTrue (r.Read (), i + "#75");
 688                                 Assert.IsNotNull (r.Value, i + "#75-2");
 689                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 690                                 Assert.IsTrue (r.Read (), i + "#74");
 691                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 692                                 Assert.IsTrue (r.Read (), i + "#75");
 693                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 694                         }
 695
 696                         Assert.IsTrue (r.Read (), "#81");
 697                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 698
 699                         Assert.IsTrue (r.Read (), "#87");
 700                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88");
 701
 702                         Assert.IsFalse (r.Read (), "#89");
 703                 }
 704
 705                 protected void Read_ArrayOrArrayExtensionOrMyArrayExtension (XamlReader r, Action validateInstance, Type extType)
 706                 {
 707                         if (extType == typeof (MyArrayExtension)) {
 708                                 Assert.IsTrue (r.Read (), "#1");
 709                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
 710                                 Assert.IsNotNull (r.Namespace, "#3");
 711                                 Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
 712                         }
 713                         Assert.IsTrue (r.Read (), "#11");
 714                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 715                         Assert.IsNotNull (r.Namespace, "#13");
 716                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 717                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 718
 719                         Assert.IsTrue (r.Read (), "#21");
 720                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 721                         var xt = new XamlType (extType, r.SchemaContext);
 722                         Assert.AreEqual (xt, r.Type, "#23");
 723                         if (validateInstance != null)
 724                                 validateInstance ();
 725
 726                         if (r is XamlXmlReader)
 727                                 ReadBase (r);
 728
 729                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 730
 731                         Assert.IsTrue (r.Read (), "#31");
 732                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 733                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33");
 734
 735                         Assert.IsTrue (r.Read (), "#41");
 736                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 737                         Assert.AreEqual ("x:Int32", r.Value, "#43");
 738
 739                         Assert.IsTrue (r.Read (), "#51");
 740                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 741
 742                         Assert.IsTrue (r.Read (), "#61");
 743                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
 744                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
 745
 746                         Assert.IsTrue (r.Read (), "#71");
 747                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
 748                         Assert.IsNull (r.Type, "#71-3");
 749                         Assert.IsNull (r.Member, "#71-4");
 750                         Assert.IsNull (r.Value, "#71-5");
 751
 752                         Assert.IsTrue (r.Read (), "#72");
 753                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 754                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 755
 756                         string [] values = {"5", "-3", "0"};
 757                         for (int i = 0; i < 3; i++) {
 758                                 Assert.IsTrue (r.Read (), i + "#73");
 759                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 760                                 Assert.IsTrue (r.Read (), i + "#74");
 761                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 762                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 763                                 Assert.IsTrue (r.Read (), i + "#75");
 764                                 Assert.IsNotNull (r.Value, i + "#75-2");
 765                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 766                                 Assert.IsTrue (r.Read (), i + "#74");
 767                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 768                                 Assert.IsTrue (r.Read (), i + "#75");
 769                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 770                         }
 771
 772                         Assert.IsTrue (r.Read (), "#81");
 773                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 774
 775                         Assert.IsTrue (r.Read (), "#83");
 776                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
 777
 778                         Assert.IsTrue (r.Read (), "#85");
 779                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ArrayExtension.Items
 780
 781                         Assert.IsTrue (r.Read (), "#87");
 782                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ArrayExtension
 783
 784                         Assert.IsFalse (r.Read (), "#89");
 785                 }
 786
 787                 // It gives Type member, not PositionalParameters... and no Items member here.
 788                 protected void Read_ArrayExtension2 (XamlReader r)
 789                 {
 790                         Assert.IsTrue (r.Read (), "#11");
 791                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 792                         Assert.IsNotNull (r.Namespace, "#13");
 793                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 794                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 795 //                      Assert.IsNull (r.Instance, "#14");
 796
 797                         Assert.IsTrue (r.Read (), "#21");
 798                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 799                         var xt = new XamlType (typeof (ArrayExtension), r.SchemaContext);
 800                         Assert.AreEqual (xt, r.Type, "#23-2");
 801 //                      Assert.IsTrue (r.Instance is ArrayExtension, "#26");
 802
 803                         if (r is XamlXmlReader)
 804                                 ReadBase (r);
 805
 806                         Assert.IsTrue (r.Read (), "#31");
 807                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 808                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33-2");
 809
 810                         Assert.IsTrue (r.Read (), "#41");
 811                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 812                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 813
 814                         Assert.IsTrue (r.Read (), "#51");
 815                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 816
 817                         Assert.IsTrue (r.Read (), "#61");
 818                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 819
 820                         Assert.IsFalse (r.Read (), "#71");
 821                         Assert.IsTrue (r.IsEof, "#72");
 822                 }
 823         }
 824
 825         public partial class XamlObjectReaderTest
 826         {
 827                 [Test]
 828                 public void Read_String ()
 829                 {
 830                         var r = new XamlObjectReader ("foo");
 831                         Read_String (r);
 832                 }
 833
 834                 [Test]
 835                 public void WriteNullMemberAsObject ()
 836                 {
 837                         var r = new XamlObjectReader (new TestClass4 ());
 838                         WriteNullMemberAsObject (r, delegate {
 839                                 Assert.IsNull (r.Instance, "#x"); }
 840                                 );
 841                 }
 842
 843                 [Test]
 844                 public void StaticMember ()
 845                 {
 846                         var r = new XamlObjectReader (new TestClass5 ());
 847                         StaticMember (r);
 848                 }
 849
 850                 [Test]
 851                 public void Skip ()
 852                 {
 853                         var r = new XamlObjectReader ("Foo");
 854                         Skip (r);
 855                 }
 856
 857                 [Test]
 858                 public void Skip2 ()
 859                 {
 860                         var r = new XamlObjectReader ("Foo");
 861                         Skip2 (r);
 862                 }
 863
 864                 [Test]
 865                 public void Read_XmlDocument ()
 866                 {
 867                         var doc = new XmlDocument ();
 868                         doc.LoadXml ("<root xmlns='urn:foo'><elem attr='val' /></root>");
 869                         var r = new XamlObjectReader (doc);
 870                         Read_XmlDocument (r);
 871                 }
 872
 873                 [Test]
 874                 public void Read_NonPrimitive ()
 875                 {
 876                         var r = new XamlObjectReader (new TestClass3 ());
 877                         Read_NonPrimitive (r);
 878                 }
 879
 880                 [Test]
 881                 public void Read_Type ()
 882                 {
 883                         var r = new XamlObjectReader (typeof (int));
 884                         Read_TypeOrTypeExtension (r);
 885                 }
 886
 887                 [Test]
 888                 public void Read_TypeExtension ()
 889                 {
 890                         var tx = new TypeExtension (typeof (int));
 891                         var r = new XamlObjectReader (tx);
 892                         Read_TypeOrTypeExtension (r);
 893                 }
 894
 895                 void Read_TypeOrTypeExtension (XamlObjectReader r)
 896                 {
 897                         Read_TypeOrTypeExtension (r, delegate {
 898                                 Assert.IsTrue (r.Instance is TypeExtension, "#26");
 899                                 }, XamlLanguage.PositionalParameters);
 900                 }
 901
 902                 [Test]
 903                 public void Read_Type2 ()
 904                 {
 905                         var r = new XamlObjectReader (typeof (TestClass1));
 906                         Read_TypeOrTypeExtension2 (r);
 907                 }
 908
 909                 [Test]
 910                 public void Read_TypeExtension2 ()
 911                 {
 912                         var r = new XamlObjectReader (new TypeExtension (typeof (TestClass1)));
 913                         Read_TypeOrTypeExtension2 (r);
 914                 }
 915
 916                 void Read_TypeOrTypeExtension2 (XamlObjectReader r)
 917                 {
 918                         Read_TypeOrTypeExtension2 (r, delegate {
 919                                 Assert.IsTrue (r.Instance is TypeExtension, "#26");
 920                         }, XamlLanguage.PositionalParameters);
 921                 }
 922
 923                 [Test]
 924                 public void Read_Reference ()
 925                 {
 926                         var r = new XamlObjectReader (new Reference ("FooBar"));
 927                         Read_Reference (r);
 928                 }
 929
 930                 [Test]
 931                 public void Read_Null ()
 932                 {
 933                         var r = new XamlObjectReader (null);
 934                         Read_NullOrNullExtension (r, (object) null);
 935                 }
 936
 937                 [Test]
 938                 public void Read_NullExtension ()
 939                 {
 940                         var o = new NullExtension ();
 941                         var r = new XamlObjectReader (o);
 942                         Read_NullOrNullExtension (r, o);
 943                 }
 944
 945                 void Read_NullOrNullExtension (XamlObjectReader r, object instance)
 946                 {
 947                         Read_NullOrNullExtension (r, delegate {
 948                                 Assert.AreEqual (instance, r.Instance, "#26"); // null and NullExtension are different here.
 949                         });
 950                 }
 951
 952                 [Test]
 953                 public void Read_StaticExtension ()
 954                 {
 955                         var r = new XamlObjectReader (new StaticExtension ("FooBar"));
 956                         Read_StaticExtension (r, XamlLanguage.PositionalParameters);
 957                 }
 958
 959                 [Test]
 960                 public void Read_ListInt32 ()
 961                 {
 962                         var obj = new List<int> (new int [] {5, -3, int.MaxValue, 0});
 963                         Read_ListInt32 (obj);
 964                 }
 965
 966                 [Test]
 967                 public void Read_ListInt32_2 ()
 968                 {
 969                         var obj = new List<int> (new int [0]);
 970                         Read_ListInt32 (obj);
 971                 }
 972
 973                 void Read_ListInt32 (List<int> obj)
 974                 {
 975                         var r = new XamlObjectReader (obj);
 976                         Read_ListInt32 (r, delegate {
 977                                 Assert.AreEqual (obj, r.Instance, "#26");
 978                                 }, obj);
 979                 }
 980
 981                 [Test]
 982                 public void Read_ArrayList ()
 983                 {
 984                         var obj = new ArrayList (new int [] {5, -3, 0});
 985                         var r = new XamlObjectReader (obj);
 986                         Read_ArrayList (r);
 987                 }
 988
 989                 [Test]
 990                 public void Read_Array ()
 991                 {
 992                         var obj = new int [] {5, -3, 0};
 993                         var r = new XamlObjectReader (obj);
 994                         Read_ArrayOrArrayExtension (r, obj);
 995                 }
 996
 997                 [Test]
 998                 public void Read_ArrayExtension ()
 999                 {
1000                         var obj = new ArrayExtension (new int [] {5, -3, 0});
1001                         var r = new XamlObjectReader (obj);
1002                         Read_ArrayOrArrayExtension (r, obj);
1003                 }
1004
1005                 [Test]
1006                 public void Read_MyArrayExtension ()
1007                 {
1008                         var obj = new MyArrayExtension (new int [] {5, -3, 0});
1009                         var r = new XamlObjectReader (obj);
1010                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, obj, typeof (MyArrayExtension));
1011                 }
1012
1013                 void Read_ArrayOrArrayExtension (XamlObjectReader r, object instance)
1014                 {
1015                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, instance, typeof (ArrayExtension));
1016                 }
1017
1018                 void Read_ArrayOrArrayExtensionOrMyArrayExtension (XamlObjectReader r, object instance, Type extType)
1019                 {
1020                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, delegate {
1021                                 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)
1022                                 }, extType);
1023                 }
1024
1025                 [Test]
1026                 public void Read_ArrayExtension2 ()
1027                 {
1028                         var r = new XamlObjectReader (new ArrayExtension (typeof (int)));
1029                         Read_ArrayExtension2 (r);
1030                 }
1031
1032                 [Test]
1033                 public void Read_DateTime ()
1034                 {
1035                         var obj = new DateTime (2010, 4, 15);
1036                         var r = new XamlObjectReader (obj);
1037                         Read_CommonClrType (r, obj);
1038                         Assert.AreEqual ("2010-04-15", Read_Initialization (r, null), "#1");
1039                 }
1040
1041                 [Test]
1042                 public void Read_TimeSpan ()
1043                 {
1044                         Read_CommonXamlPrimitive (TimeSpan.FromMinutes (4));
1045                 }
1046
1047                 [Test]
1048                 public void Read_Uri ()
1049                 {
1050                         Read_CommonXamlPrimitive (new Uri ("urn:foo"));
1051                 }
1052
1053                 [Test]
1054                 public void Read_Guid ()
1055                 {
1056                         var obj = Guid.NewGuid ();
1057                         var r = new XamlObjectReader (obj);
1058                         Assert.IsNotNull (r.SchemaContext.GetXamlType (typeof (Guid)).TypeConverter, "premise#1");
1059                         Read_CommonClrType (r, obj);
1060                         Assert.AreEqual (obj.ToString (), Read_Initialization (r, null), "#1");
1061                 }
1062
1063                 [Test]
1064                 [ExpectedException (typeof (XamlObjectReaderException))]
1065                 [Category ("NotWorking")]
1066                 public void Read_XData ()
1067                 {
1068                         var r = new XamlObjectReader (new XData () {Text = "xdata text"}); // XmlReader implementation is not visible.
1069                         while (!r.IsEof)
1070                                 r.Read ();
1071                 }
1072
1073                 [Test]
1074                 public void ReadStandardTypes ()
1075                 {
1076                         SimpleReadStandardType (new ArrayExtension ());
1077                         SimpleReadStandardType (new NullExtension ());
1078                         SimpleReadStandardType (new PropertyDefinition ());
1079                         SimpleReadStandardType (new Reference ());
1080                         SimpleReadStandardType (new StaticExtension ());
1081                         SimpleReadStandardType (new TypeExtension ());
1082                 }
1083
1084                 void SimpleReadStandardType (object instance)
1085                 {
1086                         var r = new XamlObjectReader (instance);
1087                         while (!r.IsEof)
1088                                 r.Read ();
1089                 }
1090
1091                 [Test]
1092                 public void Read_CustomMarkupExtension ()
1093                 {
1094                         var r = new XamlObjectReader (new MyExtension () { Foo = typeof (int), Bar = "v2", Baz = "v7"});
1095                         Read_CustomMarkupExtension (r);
1096                 }
1097
1098                 [Test]
1099                 public void Read_CustomMarkupExtension2 ()
1100                 {
1101                         var r = new XamlObjectReader (new MyExtension2 () { Foo = typeof (int), Bar = "v2"});
1102                         Read_CustomMarkupExtension2 (r);
1103                 }
1104
1105                 [Test]
1106                 public void Read_CustomMarkupExtension3 ()
1107                 {
1108                         var r = new XamlObjectReader (new MyExtension3 () { Foo = typeof (int), Bar = "v2"});
1109                         Read_CustomMarkupExtension3 (r);
1110                 }
1111
1112                 [Test]
1113                 public void Read_CustomMarkupExtension4 ()
1114                 {
1115                         var r = new XamlObjectReader (new MyExtension4 () { Foo = typeof (int), Bar = "v2"});
1116                         Read_CustomMarkupExtension4 (r);
1117                 }
1118
1119                 [Test]
1120                 public void Read_CustomMarkupExtension5 ()
1121                 {
1122                         // This cannot be written to XamlXmlWriter though...
1123
1124                         var r = new XamlObjectReader (new MyExtension5 ("foo", "bar"));
1125                         Read_CustomMarkupExtension5 (r);
1126                 }
1127
1128                 [Test]
1129                 public void Read_CustomMarkupExtension6 ()
1130                 {
1131                         var r = new XamlObjectReader (new MyExtension6 ("foo"));
1132                         Read_CustomMarkupExtension6 (r);
1133                 }
1134
1135                 [Test] // not commonized
1136                 public void Read_ArgumentAttributed ()
1137                 {
1138                         var obj = new ArgumentAttributed ("foo", "bar");
1139                         var r = new XamlObjectReader (obj);
1140                         Read_CommonClrType (r, obj, new KeyValuePair<string,string> ("x", XamlLanguage.Xaml2006Namespace));
1141                         var args = Read_AttributedArguments_String (r, new string [] {"arg1", "arg2"});
1142                         Assert.AreEqual ("foo", args [0], "#1");
1143                         Assert.AreEqual ("bar", args [1], "#2");
1144                 }
1145         }
1146
1147         public partial class XamlReaderTestBase
1148         {
1149                 protected void Read_CustomMarkupExtension (XamlReader r)
1150                 {
1151                         r.Read (); // ns
1152                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1153                         r.Read (); // ns
1154                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-2");
1155                         r.Read ();
1156                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1157                         Assert.IsFalse (r.IsEof, "#1");
1158                         var xt = r.Type;
1159
1160                         if (r is XamlXmlReader)
1161                                 ReadBase (r);
1162
1163                         r.Read ();
1164                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#2-1");
1165                         Assert.IsFalse (r.IsEof, "#2-2");
1166                         Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#2-3");
1167
1168                         Assert.IsTrue (r.Read (), "#2-4");
1169                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#2-5");
1170                         Assert.AreEqual ("v2", r.Value, "#2-6");
1171
1172                         Assert.IsTrue (r.Read (), "#2-7");
1173                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#2-8");
1174
1175                         r.Read ();
1176                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-1");
1177                         Assert.IsFalse (r.IsEof, "#3-2");
1178                         Assert.AreEqual (xt.GetMember ("Baz"), r.Member, "#3-3");
1179
1180                         Assert.IsTrue (r.Read (), "#3-4");
1181                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#3-5");
1182                         Assert.AreEqual ("v7", r.Value, "#3-6");
1183
1184                         Assert.IsTrue (r.Read (), "#3-7");
1185                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#3-8");
1186
1187                         r.Read ();
1188                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#4-1");
1189                         Assert.IsFalse (r.IsEof, "#4-2");
1190                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4-3");
1191                         Assert.IsTrue (r.Read (), "#4-4");
1192                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#4-5");
1193                         Assert.AreEqual ("x:Int32", r.Value, "#4-6");
1194
1195                         Assert.IsTrue (r.Read (), "#4-7");
1196                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#4-8");
1197
1198                         Assert.IsTrue (r.Read (), "#5");
1199                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#5-2");
1200
1201                         Assert.IsFalse (r.Read (), "#6");
1202                 }
1203
1204                 protected void Read_CustomMarkupExtension2 (XamlReader r)
1205                 {
1206                         r.Read (); // ns
1207                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1208                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1209                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1210                         var xt = r.Type;
1211                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension2)), xt, "#2");
1212
1213                         if (r is XamlXmlReader)
1214                                 ReadBase (r);
1215
1216                         Assert.IsTrue (r.Read (), "#3");
1217                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1218                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1219                         Assert.IsTrue (r.Read (), "#5");
1220                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension2", r.Value, "#6");
1221                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1222                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1223                         Assert.IsFalse (r.Read (), "#9");
1224                 }
1225
1226                 protected void Read_CustomMarkupExtension3 (XamlReader r)
1227                 {
1228                         r.Read (); // ns
1229                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1230                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1231                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1232                         var xt = r.Type;
1233                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension3)), xt, "#2");
1234
1235                         if (r is XamlXmlReader)
1236                                 ReadBase (r);
1237
1238                         Assert.IsTrue (r.Read (), "#3");
1239                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1240                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1241                         Assert.IsTrue (r.Read (), "#5");
1242                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension3", r.Value, "#6");
1243                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1244                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1245                         Assert.IsFalse (r.Read (), "#9");
1246                 }
1247
1248                 protected void Read_CustomMarkupExtension4 (XamlReader r)
1249                 {
1250                         r.Read (); // ns
1251                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1252                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1253                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1254                         var xt = r.Type;
1255                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension4)), xt, "#2");
1256
1257                         if (r is XamlXmlReader)
1258                                 ReadBase (r);
1259
1260                         Assert.IsTrue (r.Read (), "#3");
1261                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1262                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1263                         Assert.IsTrue (r.Read (), "#5");
1264                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension4", r.Value, "#6");
1265                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1266                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1267                         Assert.IsFalse (r.Read (), "#9");
1268                 }
1269
1270                 protected void Read_CustomMarkupExtension5 (XamlReader r)
1271                 {
1272                         r.Read (); // ns
1273                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1274                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1275                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1276                         var xt = r.Type;
1277                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension5)), xt, "#2");
1278
1279                         if (r is XamlXmlReader)
1280                                 ReadBase (r);
1281
1282                         Assert.IsTrue (r.Read (), "#3");
1283                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1284                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#4");
1285                         Assert.IsTrue (r.Read (), "#5");
1286                         Assert.AreEqual ("foo", r.Value, "#6");
1287                         Assert.IsTrue (r.Read (), "#7");
1288                         Assert.AreEqual ("bar", r.Value, "#8");
1289                         Assert.IsTrue (r.Read (), "#9");
1290                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#10");
1291                         Assert.IsTrue (r.Read (), "#11");
1292                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#12");
1293                         Assert.IsFalse (r.Read (), "#13");
1294                 }
1295
1296                 protected void Read_CustomMarkupExtension6 (XamlReader r)
1297                 {
1298                         r.Read (); // ns
1299                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1300                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1301                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1302                         var xt = r.Type;
1303                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension6)), xt, "#2");
1304
1305                         if (r is XamlXmlReader)
1306                                 ReadBase (r);
1307
1308                         Assert.IsTrue (r.Read (), "#3");
1309                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1310                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4"); // this is the difference between MyExtension5 and MyExtension6: it outputs constructor arguments as normal members
1311                         Assert.IsTrue (r.Read (), "#5");
1312                         Assert.AreEqual ("foo", r.Value, "#6");
1313                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1314                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1315                         Assert.IsFalse (r.Read (), "#9");
1316                 }
1317
1318                 protected void Read_Dictionary (XamlReader r)
1319                 {
1320                         Assert.IsTrue (r.Read (), "ns#1-1");
1321                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1322                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1323                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1324                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "ns#1-5");
1325
1326                         Assert.IsTrue (r.Read (), "ns#2-1");
1327                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1328                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1329                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1330                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1331
1332                         Assert.IsTrue (r.Read (), "so#1-1");
1333                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1334                         var xt = new XamlType (typeof (Dictionary<string,object>), r.SchemaContext);
1335                         Assert.AreEqual (xt, r.Type, "so#1-3");
1336 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1337
1338                         if (r is XamlXmlReader)
1339                                 ReadBase (r);
1340
1341                         Assert.IsTrue (r.Read (), "smitems#1");
1342                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smitems#2");
1343                         Assert.AreEqual (XamlLanguage.Items, r.Member, "smitems#3");
1344
1345                         for (int i = 0; i < 2; i++) {
1346
1347                                 // start of an item
1348                                 Assert.IsTrue (r.Read (), "soi#1-1." + i);
1349                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "soi#1-2." + i);
1350                                 var xt2 = new XamlType (typeof (double), r.SchemaContext);
1351                                 Assert.AreEqual (xt2, r.Type, "soi#1-3." + i);
1352
1353                                 Assert.IsTrue (r.Read (), "smi#1-1." + i);
1354                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#1-2." + i);
1355                                 Assert.AreEqual (XamlLanguage.Key, r.Member, "smi#1-3." + i);
1356
1357                                 Assert.IsTrue (r.Read (), "svi#1-1." + i);
1358                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#1-2." + i);
1359                                 Assert.AreEqual (i == 0 ? "Foo" : "Bar", r.Value, "svi#1-3." + i);
1360
1361                                 Assert.IsTrue (r.Read (), "emi#1-1." + i);
1362                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#1-2." + i);
1363
1364                                 Assert.IsTrue (r.Read (), "smi#2-1." + i);
1365                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#2-2." + i);
1366                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, "smi#2-3." + i);
1367
1368                                 Assert.IsTrue (r.Read (), "svi#2-1." + i);
1369                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#2-2." + i);
1370                                 Assert.AreEqual (i == 0 ? "5" : "-6.5", r.Value, "svi#2-3." + i); // converted to string(!)
1371
1372                                 Assert.IsTrue (r.Read (), "emi#2-1." + i);
1373                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#2-2." + i);
1374
1375                                 Assert.IsTrue (r.Read (), "eoi#1-1." + i);
1376                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eoi#1-2." + i);
1377                                 // end of an item
1378                         }
1379
1380                         Assert.IsTrue (r.Read (), "emitems#1");
1381                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emitems#2"); // XamlLanguage.Items
1382
1383                         Assert.IsTrue (r.Read (), "eo#1-1");
1384                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2"); // Dictionary
1385
1386                         Assert.IsFalse (r.Read (), "end");
1387                 }
1388
1389                 protected void Read_Dictionary2 (XamlReader r, XamlMember ctorArgMember)
1390                 {
1391                         Assert.IsTrue (r.Read (), "ns#1-1");
1392                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1393                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1394                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1395                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "ns#1-5");
1396
1397                         Assert.IsTrue (r.Read (), "ns#2-1");
1398                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1399                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1400                         Assert.AreEqual ("s", r.Namespace.Prefix, "ns#2-4");
1401                         Assert.AreEqual ("clr-namespace:System;assembly=mscorlib", r.Namespace.Namespace, "ns#2-5");
1402
1403                         Assert.IsTrue (r.Read (), "ns#3-1");
1404                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#3-2");
1405                         Assert.IsNotNull (r.Namespace, "ns#3-3");
1406                         Assert.AreEqual ("sx", r.Namespace.Prefix, "ns#3-4");
1407                         Assert.AreEqual ("clr-namespace:System.Xaml;assembly=System.Xaml", r.Namespace.Namespace, "ns#3-5");
1408
1409                         Assert.IsTrue (r.Read (), "ns#4-1");
1410                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#4-2");
1411                         Assert.IsNotNull (r.Namespace, "ns#4-3");
1412                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#4-4");
1413                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#4-5");
1414
1415                         Assert.IsTrue (r.Read (), "so#1-1");
1416                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1417                         var xt = new XamlType (typeof (Dictionary<string,Type>), r.SchemaContext);
1418                         Assert.AreEqual (xt, r.Type, "so#1-3");
1419 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1420
1421                         if (r is XamlXmlReader)
1422                                 ReadBase (r);
1423
1424                         Assert.IsTrue (r.Read (), "smitems#1");
1425                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smitems#2");
1426                         Assert.AreEqual (XamlLanguage.Items, r.Member, "smitems#3");
1427
1428                         for (int i = 0; i < 2; i++) {
1429
1430                                 // start of an item
1431                                 Assert.IsTrue (r.Read (), "soi#1-1." + i);
1432                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "soi#1-2." + i);
1433                                 var xt2 = XamlLanguage.Type;
1434                                 Assert.AreEqual (xt2, r.Type, "soi#1-3." + i);
1435
1436                                 if (r is XamlObjectReader) {
1437                                         Read_Dictionary2_ConstructorArgument (r, ctorArgMember, i);
1438                                         Read_Dictionary2_Key (r, i);
1439                                 } else {
1440                                         Read_Dictionary2_Key (r, i);
1441                                         Read_Dictionary2_ConstructorArgument (r, ctorArgMember, i);
1442                                 }
1443
1444                                 Assert.IsTrue (r.Read (), "eoi#1-1." + i);
1445                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eoi#1-2." + i);
1446                                 // end of an item
1447                         }
1448
1449                         Assert.IsTrue (r.Read (), "emitems#1");
1450                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emitems#2"); // XamlLanguage.Items
1451
1452                         Assert.IsTrue (r.Read (), "eo#1-1");
1453                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2"); // Dictionary
1454
1455                         Assert.IsFalse (r.Read (), "end");
1456                 }
1457
1458                 void Read_Dictionary2_ConstructorArgument (XamlReader r, XamlMember ctorArgMember, int i)
1459                 {
1460                         Assert.IsTrue (r.Read (), "smi#1-1." + i);
1461                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#1-2." + i);
1462                         Assert.AreEqual (ctorArgMember, r.Member, "smi#1-3." + i);
1463
1464                         Assert.IsTrue (r.Read (), "svi#1-1." + i);
1465                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#1-2." + i);
1466                         Assert.AreEqual (i == 0 ? "x:Int32" : "Dictionary(s:Type, sx:XamlType)", r.Value, "svi#1-3." + i);
1467
1468                         Assert.IsTrue (r.Read (), "emi#1-1." + i);
1469                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#1-2." + i);
1470                 }
1471
1472                 void Read_Dictionary2_Key (XamlReader r, int i)
1473                 {
1474                         Assert.IsTrue (r.Read (), "smi#2-1." + i);
1475                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#2-2." + i);
1476                         Assert.AreEqual (XamlLanguage.Key, r.Member, "smi#2-3." + i);
1477
1478                         Assert.IsTrue (r.Read (), "svi#2-1." + i);
1479                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#2-2." + i);
1480                         Assert.AreEqual (i == 0 ? "Foo" : "Bar", r.Value, "svi#2-3." + i);
1481
1482                         Assert.IsTrue (r.Read (), "emi#2-1." + i);
1483                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#2-2." + i);
1484                 }
1485
1486                 protected void PositionalParameters1 (XamlReader r)
1487                 {
1488                         // ns1 > T:PositionalParametersClass1 > M:_PositionalParameters > foo > 5 > EM:_PositionalParameters > ET:PositionalParametersClass1
1489
1490                         Assert.IsTrue (r.Read (), "ns#1-1");
1491                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1492                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1493                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1494                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1495
1496                         Assert.IsTrue (r.Read (), "so#1-1");
1497                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1498                         var xt = new XamlType (typeof (PositionalParametersClass1), r.SchemaContext);
1499                         Assert.AreEqual (xt, r.Type, "so#1-3");
1500 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1501
1502                         if (r is XamlXmlReader)
1503                                 ReadBase (r);
1504
1505                         Assert.IsTrue (r.Read (), "sposprm#1");
1506                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1507                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "sposprm#3");
1508
1509                         Assert.IsTrue (r.Read (), "sva#1-1");
1510                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1511                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1512
1513                         Assert.IsTrue (r.Read (), "sva#2-1");
1514                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#2-2");
1515                         Assert.AreEqual ("5", r.Value, "sva#2-3");
1516
1517                         Assert.IsTrue (r.Read (), "eposprm#1");
1518                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2"); // XamlLanguage.PositionalParameters
1519
1520                         Assert.IsTrue (r.Read (), "eo#1-1");
1521                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1522
1523                         Assert.IsFalse (r.Read (), "end");
1524                 }
1525
1526                 protected void PositionalParameters2 (XamlReader r)
1527                 {
1528                         // ns1 > T:PositionalParametersWrapper > M:Body > T:PositionalParametersClass1 > M:_PositionalParameters > foo > 5 > EM:_PositionalParameters > ET:PositionalParametersClass1
1529
1530                         Assert.IsTrue (r.Read (), "ns#1-1");
1531                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1532                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1533                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1534                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1535
1536                         Assert.IsTrue (r.Read (), "so#1-1");
1537                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1538                         var xt = new XamlType (typeof (PositionalParametersWrapper), r.SchemaContext);
1539                         Assert.AreEqual (xt, r.Type, "so#1-3");
1540 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1541
1542                         if (r is XamlXmlReader)
1543                                 ReadBase (r);
1544
1545                         Assert.IsTrue (r.Read (), "sm#1-1");
1546                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#1-2");
1547                         Assert.AreEqual (xt.GetMember ("Body"), r.Member, "sm#1-3");
1548
1549                         xt = new XamlType (typeof (PositionalParametersClass1), r.SchemaContext);
1550                         Assert.IsTrue (r.Read (), "so#2-1");
1551                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1552                         Assert.AreEqual (xt, r.Type, "so#2-3");
1553 //                      Assert.AreEqual (obj.Body, r.Instance, "so#2-4");
1554
1555                         Assert.IsTrue (r.Read (), "sposprm#1");
1556                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1557                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "sposprm#3");
1558
1559                         Assert.IsTrue (r.Read (), "sva#1-1");
1560                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1561                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1562
1563                         Assert.IsTrue (r.Read (), "sva#2-1");
1564                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#2-2");
1565                         Assert.AreEqual ("5", r.Value, "sva#2-3");
1566
1567                         Assert.IsTrue (r.Read (), "eposprm#1");
1568                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2"); // XamlLanguage.PositionalParameters
1569
1570                         Assert.IsTrue (r.Read (), "eo#2-1");
1571                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1572
1573                         Assert.IsTrue (r.Read (), "em#1-1");
1574                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eo#1-2");
1575
1576                         Assert.IsTrue (r.Read (), "eo#1-1");
1577                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1578
1579                         Assert.IsFalse (r.Read (), "end");
1580                 }
1581
1582                 protected void ComplexPositionalParameters (XamlReader r)
1583                 {
1584                         Assert.IsTrue (r.Read (), "ns#1-1");
1585                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1586                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1587                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1588                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1589
1590                         Assert.IsTrue (r.Read (), "ns#2-1");
1591                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1592                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1593                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1594                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1595
1596                         Assert.IsTrue (r.Read (), "so#1-1");
1597                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1598                         var xt = new XamlType (typeof (ComplexPositionalParameterWrapper), r.SchemaContext);
1599                         Assert.AreEqual (xt, r.Type, "so#1-3");
1600 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1601
1602                         if (r is XamlXmlReader)
1603                                 ReadBase (r);
1604
1605                         Assert.IsTrue (r.Read (), "sm#1-1");
1606                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#1-2");
1607                         Assert.AreEqual (xt.GetMember ("Param"), r.Member, "sm#1-3");
1608
1609                         xt = r.SchemaContext.GetXamlType (typeof (ComplexPositionalParameterClass));
1610                         Assert.IsTrue (r.Read (), "so#2-1");
1611                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1612                         Assert.AreEqual (xt, r.Type, "so#2-3");
1613 //                      Assert.AreEqual (obj.Param, r.Instance, "so#2-4");
1614
1615                         Assert.IsTrue (r.Read (), "sarg#1");
1616                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sarg#2");
1617                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "sarg#3");
1618
1619                         Assert.IsTrue (r.Read (), "so#3-1");
1620                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#3-2");
1621                         xt = r.SchemaContext.GetXamlType (typeof (ComplexPositionalParameterValue));
1622                         Assert.AreEqual (xt, r.Type, "so#3-3");
1623
1624                         Assert.IsTrue (r.Read (), "sm#3-1");
1625                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#3-2");
1626                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "sm#3-3");
1627                         Assert.IsTrue (r.Read (), "v#3-1");
1628                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "v#3-2");
1629                         Assert.AreEqual ("foo", r.Value, "v#3-3");
1630
1631                         Assert.IsTrue (r.Read (), "em#3-1");
1632                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em#3-2");
1633                         Assert.IsTrue (r.Read (), "eo#3-1");
1634                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#3-2");
1635
1636                         Assert.IsTrue (r.Read (), "earg#1");
1637                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "earg#2"); // XamlLanguage.Arguments
1638
1639                         Assert.IsTrue (r.Read (), "eo#2-1");
1640                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1641
1642                         Assert.IsTrue (r.Read (), "em#1-1");
1643                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eo#1-2");
1644
1645                         Assert.IsTrue (r.Read (), "eo#1-1");
1646                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1647
1648                         Assert.IsFalse (r.Read (), "end");
1649                 }
1650
1651                 protected void Read_ListWrapper (XamlReader r)
1652                 {
1653                         Assert.IsTrue (r.Read (), "#1");
1654                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
1655                         Assert.IsNotNull (r.Namespace, "#3");
1656                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
1657
1658                         Assert.IsTrue (r.Read (), "#11");
1659                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
1660                         Assert.IsNotNull (r.Namespace, "#13");
1661                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
1662                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
1663
1664                         Assert.IsTrue (r.Read (), "#21");
1665                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
1666                         var xt = new XamlType (typeof (ListWrapper), r.SchemaContext);
1667                         Assert.AreEqual (xt, r.Type, "#23");
1668 //                      Assert.AreEqual (obj, r.Instance, "#26");
1669
1670                         if (r is XamlXmlReader)
1671                                 ReadBase (r);
1672
1673                         Assert.IsTrue (r.Read (), "#61");
1674                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
1675                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
1676
1677                         Assert.IsTrue (r.Read (), "#71");
1678                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
1679                         Assert.IsNull (r.Type, "#71-3");
1680                         Assert.IsNull (r.Member, "#71-4");
1681                         Assert.IsNull (r.Value, "#71-5");
1682
1683                         Assert.IsTrue (r.Read (), "#72");
1684                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
1685                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
1686
1687                         string [] values = {"5", "-3", "0"};
1688                         for (int i = 0; i < 3; i++) {
1689                                 Assert.IsTrue (r.Read (), i + "#73");
1690                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
1691                                 Assert.IsTrue (r.Read (), i + "#74");
1692                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
1693                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
1694                                 Assert.IsTrue (r.Read (), i + "#75");
1695                                 Assert.IsNotNull (r.Value, i + "#75-2");
1696                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
1697                                 Assert.IsTrue (r.Read (), i + "#74");
1698                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
1699                                 Assert.IsTrue (r.Read (), i + "#75");
1700                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
1701                         }
1702
1703                         Assert.IsTrue (r.Read (), "#81");
1704                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
1705
1706                         Assert.IsTrue (r.Read (), "#83");
1707                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
1708
1709                         Assert.IsTrue (r.Read (), "#85");
1710                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ListWrapper.Items
1711
1712                         Assert.IsTrue (r.Read (), "#87");
1713                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ListWrapper
1714
1715                         Assert.IsFalse (r.Read (), "#89");
1716                 }
1717
1718                 protected void Read_ListWrapper2 (XamlReader r)
1719                 {
1720                         Assert.IsTrue (r.Read (), "#1");
1721                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
1722                         Assert.IsNotNull (r.Namespace, "#3");
1723                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
1724
1725                         Assert.IsTrue (r.Read (), "#6");
1726                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
1727                         Assert.IsNotNull (r.Namespace, "#8");
1728                         Assert.AreEqual ("scg", r.Namespace.Prefix, "#8-2");
1729                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "#8-3");
1730
1731                         Assert.IsTrue (r.Read (), "#11");
1732                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
1733                         Assert.IsNotNull (r.Namespace, "#13");
1734                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
1735                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
1736
1737                         Assert.IsTrue (r.Read (), "#21");
1738                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
1739                         var xt = new XamlType (typeof (ListWrapper2), r.SchemaContext);
1740                         Assert.AreEqual (xt, r.Type, "#23");
1741 //                      Assert.AreEqual (obj, r.Instance, "#26");
1742
1743                         if (r is XamlXmlReader)
1744                                 ReadBase (r);
1745
1746                         Assert.IsTrue (r.Read (), "#61");
1747                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
1748                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
1749
1750                         Assert.IsTrue (r.Read (), "#71");
1751                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#71-2");
1752                         xt = r.SchemaContext.GetXamlType (typeof (List<int>));
1753                         Assert.AreEqual (xt, r.Type, "#71-3");
1754                         Assert.IsNull (r.Member, "#71-4");
1755                         Assert.IsNull (r.Value, "#71-5");
1756
1757                         // Capacity
1758                         Assert.IsTrue (r.Read (), "#31");
1759                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
1760                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
1761
1762                         Assert.IsTrue (r.Read (), "#41");
1763                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
1764                         // The value is implementation details, not testable.
1765                         //Assert.AreEqual ("3", r.Value, "#43");
1766
1767                         Assert.IsTrue (r.Read (), "#51");
1768                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
1769
1770                         // Items
1771                         Assert.IsTrue (r.Read (), "#72");
1772                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
1773                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
1774
1775                         string [] values = {"5", "-3", "0"};
1776                         for (int i = 0; i < 3; i++) {
1777                                 Assert.IsTrue (r.Read (), i + "#73");
1778                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
1779                                 Assert.IsTrue (r.Read (), i + "#74");
1780                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
1781                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
1782                                 Assert.IsTrue (r.Read (), i + "#75");
1783                                 Assert.IsNotNull (r.Value, i + "#75-2");
1784                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
1785                                 Assert.IsTrue (r.Read (), i + "#74");
1786                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
1787                                 Assert.IsTrue (r.Read (), i + "#75");
1788                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
1789                         }
1790
1791                         Assert.IsTrue (r.Read (), "#81");
1792                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
1793
1794                         Assert.IsTrue (r.Read (), "#83");
1795                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // StartObject(of List<int>)
1796
1797                         Assert.IsTrue (r.Read (), "#85");
1798                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ListWrapper.Items
1799
1800                         Assert.IsTrue (r.Read (), "#87");
1801                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ListWrapper
1802
1803                         Assert.IsFalse (r.Read (), "#89");
1804                 }
1805
1806                 protected void ContentIncluded (XamlReader r)
1807                 {
1808                         Assert.IsTrue (r.Read (), "ns#1-1");
1809                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1810                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1811                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1812                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1813
1814                         Assert.IsTrue (r.Read (), "so#1-1");
1815                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1816                         var xt = new XamlType (typeof (ContentIncludedClass), r.SchemaContext);
1817                         Assert.AreEqual (xt, r.Type, "so#1-3");
1818
1819                         if (r is XamlXmlReader)
1820                                 ReadBase (r);
1821
1822                         Assert.IsTrue (r.Read (), "sposprm#1");
1823                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1824                         Assert.AreEqual (xt.GetMember ("Content"), r.Member, "sposprm#3");
1825
1826                         Assert.IsTrue (r.Read (), "sva#1-1");
1827                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1828                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1829
1830                         Assert.IsTrue (r.Read (), "eposprm#1");
1831                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2"); // XamlLanguage.PositionalParameters
1832
1833                         Assert.IsTrue (r.Read (), "eo#1-1");
1834                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1835
1836                         Assert.IsFalse (r.Read (), "end");
1837                 }
1838
1839                 protected void Read_CommonXamlPrimitive (object obj)
1840                 {
1841                         var r = new XamlObjectReader (obj);
1842                         Read_CommonXamlType (r);
1843                         Read_Initialization (r, obj);
1844                 }
1845
1846                 // from StartMember of Initialization to EndMember
1847                 protected string Read_Initialization (XamlReader r, object comparableValue)
1848                 {
1849                         Assert.IsTrue (r.Read (), "init#1");
1850                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "init#2");
1851                         Assert.IsNotNull (r.Member, "init#3");
1852                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "init#3-2");
1853                         Assert.IsTrue (r.Read (), "init#4");
1854                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "init#5");
1855                         Assert.AreEqual (typeof (string), r.Value.GetType (), "init#6");
1856                         string ret = (string) r.Value;
1857                         if (comparableValue != null)
1858                                 Assert.AreEqual (comparableValue.ToString (), r.Value, "init#6-2");
1859                         Assert.IsTrue (r.Read (), "init#7");
1860                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "init#8");
1861                         return ret;
1862                 }
1863
1864                 protected object [] Read_AttributedArguments_String (XamlReader r, string [] argNames) // valid only for string arguments.
1865                 {
1866                         object [] ret = new object [argNames.Length];
1867
1868                         Assert.IsTrue (r.Read (), "attarg.Arguments.Start1");
1869                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.Arguments.Start2");
1870                         Assert.IsNotNull (r.Member, "attarg.Arguments.Start3");
1871                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "attarg.Arguments.Start4");
1872                         for (int i = 0; i < argNames.Length; i++) {
1873                                 string arg = argNames [i];
1874                                 Assert.IsTrue (r.Read (), "attarg.ArgStartObject1." + arg);
1875                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "attarg.ArgStartObject2." + arg);
1876                                 Assert.AreEqual (typeof (string), r.Type.UnderlyingType, "attarg.ArgStartObject3." + arg);
1877                                 Assert.IsTrue (r.Read (), "attarg.ArgStartMember1." + arg);
1878                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.ArgStartMember2." + arg);
1879                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, "attarg.ArgStartMember3." + arg); // (as the argument is string here by definition)
1880                                 Assert.IsTrue (r.Read (), "attarg.ArgValue1." + arg);
1881                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "attarg.ArgValue2." + arg);
1882                                 Assert.AreEqual (typeof (string), r.Value.GetType (), "attarg.ArgValue3." + arg);
1883                                 ret [i] = r.Value;
1884                                 Assert.IsTrue (r.Read (), "attarg.ArgEndMember1." + arg);
1885                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.ArgEndMember2." + arg);
1886                                 Assert.IsTrue (r.Read (), "attarg.ArgEndObject1." + arg);
1887                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "attarg.ArgEndObject2." + arg);
1888                         }
1889                         Assert.IsTrue (r.Read (), "attarg.Arguments.End1");
1890                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.Arguments.End2");
1891                         return ret;
1892                 }
1893
1894                 // from initial to StartObject
1895                 protected void Read_CommonXamlType (XamlObjectReader r)
1896                 {
1897                         Read_CommonXamlType (r, delegate {
1898                                 Assert.IsNull (r.Instance, "ct#4");
1899                                 });
1900                 }
1901
1902                 protected void Read_CommonXamlType (XamlReader r, Action validateInstance)
1903                 {
1904                         Assert.IsTrue (r.Read (), "ct#1");
1905                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
1906                         Assert.IsNotNull (r.Namespace, "ct#3");
1907                         Assert.AreEqual ("x", r.Namespace.Prefix, "ct#3-2");
1908                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ct#3-3");
1909                         if (validateInstance != null)
1910                                 validateInstance ();
1911
1912                         Assert.IsTrue (r.Read (), "ct#5");
1913                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#6");
1914                 }
1915
1916                 // from initial to StartObject
1917                 protected void Read_CommonClrType (XamlReader r, object obj, params KeyValuePair<string,string> [] additionalNamespaces)
1918                 {
1919                         Assert.IsTrue (r.Read (), "ct#1");
1920                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
1921                         Assert.IsNotNull (r.Namespace, "ct#3");
1922                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ct#3-2");
1923                         Assert.AreEqual ("clr-namespace:" + obj.GetType ().Namespace + ";assembly=" + obj.GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ct#3-3");
1924
1925                         foreach (var kvp in additionalNamespaces) {
1926                                 Assert.IsTrue (r.Read (), "ct#4." + kvp.Key);
1927                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#5." + kvp.Key);
1928                                 Assert.IsNotNull (r.Namespace, "ct#6." + kvp.Key);
1929                                 Assert.AreEqual (kvp.Key, r.Namespace.Prefix, "ct#6-2." + kvp.Key);
1930                                 Assert.AreEqual (kvp.Value, r.Namespace.Namespace, "ct#6-3." + kvp.Key);
1931                         }
1932
1933                         Assert.IsTrue (r.Read (), "ct#7");
1934                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#8");
1935                 }
1936
1937                 protected void ReadBase (XamlReader r)
1938                 {
1939                         Assert.IsTrue (r.Read (), "sbase#1");
1940                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sbase#2");
1941                         Assert.AreEqual (XamlLanguage.Base, r.Member, "sbase#3");
1942
1943                         Assert.IsTrue (r.Read (), "vbase#1");
1944                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vbase#2");
1945                         Assert.IsTrue (r.Value is string, "vbase#3");
1946
1947                         Assert.IsTrue (r.Read (), "ebase#1");
1948                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "ebase#2");
1949                 }
1950         }
1951
1952         public partial class XamlObjectReaderTest
1953         {
1954                 [Test]
1955                 public void Read_Dictionary ()
1956                 {
1957                         var obj = new Dictionary<string,object> ();
1958                         obj ["Foo"] = 5.0;
1959                         obj ["Bar"] = -6.5;
1960                         var r = new XamlObjectReader (obj);
1961                         Read_Dictionary (r);
1962                 }
1963
1964                 [Test]
1965                 public void Read_Dictionary2 ()
1966                 {
1967                         var obj = new Dictionary<string,Type> ();
1968                         obj ["Foo"] = typeof (int);
1969                         obj ["Bar"] = typeof (Dictionary<Type,XamlType>);
1970                         var r = new XamlObjectReader (obj);
1971                         Read_Dictionary2 (r, XamlLanguage.PositionalParameters);
1972                 }
1973
1974                 [Test]
1975                 public void PositionalParameters1 ()
1976                 {
1977                         // Note: this can be read, but cannot be written to XML.
1978                         var obj = new PositionalParametersClass1 ("foo", 5);
1979                         var r = new XamlObjectReader (obj);
1980                         PositionalParameters1 (r);
1981                 }
1982
1983                 [Test]
1984                 public void PositionalParameters2 ()
1985                 {
1986                         var obj = new PositionalParametersWrapper ("foo", 5);
1987                         var r = new XamlObjectReader (obj);
1988                         PositionalParameters2 (r);
1989                 }
1990
1991                 [Test]
1992                 public void ComplexPositionalParameters ()
1993                 {
1994                         var obj = new ComplexPositionalParameterWrapper () { Param = new ComplexPositionalParameterClass (new ComplexPositionalParameterValue () { Foo = "foo" })};
1995                         var r = new XamlObjectReader (obj);
1996                         ComplexPositionalParameters (r);
1997                 }
1998
1999                 [Test]
2000                 public void Read_ListWrapper ()
2001                 {
2002                         var obj = new ListWrapper (new List<int> (new int [] {5, -3, 0}));
2003                         var r = new XamlObjectReader (obj);
2004                         Read_ListWrapper (r);
2005                 }
2006
2007                 [Test]
2008                 public void Read_ListWrapper2 () // read-write list member.
2009                 {
2010                         var obj = new ListWrapper2 (new List<int> (new int [] {5, -3, 0}));
2011                         var r = new XamlObjectReader (obj);
2012                         Read_ListWrapper2 (r);
2013                 }
2014
2015                 [Test]
2016                 public void ContentIncluded ()
2017                 {
2018                         var obj = new ContentIncludedClass () { Content = "foo" };
2019                         var r = new XamlObjectReader (obj);
2020                         ContentIncluded (r);
2021                 }
2022         }
2023 }