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 (XamlLanguage.Type, 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                         Assert.IsNotNull (XamlLanguage.Type.SchemaContext, "#23-3");
 478                         Assert.IsNotNull (r.SchemaContext, "#23-4");
 479                         Assert.AreNotEqual (XamlLanguage.Type.SchemaContext, r.SchemaContext, "#23-5");
 480                         Assert.AreNotEqual (XamlLanguage.Reference.SchemaContext, xt.SchemaContext, "#23-6");
 481                         Assert.AreEqual (XamlLanguage.Reference, xt, "#23-7");
 482
 483                         if (r is XamlXmlReader)
 484                                 ReadBase (r);
 485
 486                         Assert.IsTrue (r.Read (), "#31");
 487                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 488                         // unlike TypeExtension there is no PositionalParameters.
 489                         Assert.AreEqual (xt.GetMember ("Name"), r.Member, "#33-2");
 490
 491                         // It is a ContentProperty (besides [ConstructorArgument])
 492                         Assert.IsTrue (r.Read (), "#41");
 493                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 494                         Assert.AreEqual ("FooBar", r.Value, "#43-2");
 495
 496                         Assert.IsTrue (r.Read (), "#51");
 497                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 498
 499                         Assert.IsTrue (r.Read (), "#61");
 500                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 501
 502                         Assert.IsFalse (r.Read (), "#71");
 503                         Assert.IsTrue (r.IsEof, "#72");
 504                 }
 505
 506                 protected void Read_NullOrNullExtension (XamlReader r, Action validateInstance)
 507                 {
 508                         Assert.IsTrue (r.Read (), "#11");
 509                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 510                         Assert.IsNotNull (r.Namespace, "#13");
 511                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 512                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 513 //                      Assert.IsNull (r.Instance, "#14");
 514
 515                         Assert.IsTrue (r.Read (), "#21");
 516                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 517                         Assert.AreEqual (new XamlType (typeof (NullExtension), r.SchemaContext), r.Type, "#23-2");
 518                         if (validateInstance != null)
 519                                 validateInstance ();
 520
 521                         if (r is XamlXmlReader)
 522                                 ReadBase (r);
 523
 524                         Assert.IsTrue (r.Read (), "#61");
 525                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 526
 527                         Assert.IsFalse (r.Read (), "#71");
 528                         Assert.IsTrue (r.IsEof, "#72");
 529                 }
 530
 531                 // almost identical to TypeExtension (only type/instance difference)
 532                 protected void Read_StaticExtension (XamlReader r, XamlMember ctorArgMember)
 533                 {
 534                         Assert.IsTrue (r.Read (), "#11");
 535                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 536                         Assert.IsNotNull (r.Namespace, "#13");
 537                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 538                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 539 //                      Assert.IsNull (r.Instance, "#14");
 540
 541                         Assert.IsTrue (r.Read (), "#21");
 542                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 543                         Assert.AreEqual (new XamlType (typeof (StaticExtension), r.SchemaContext), r.Type, "#23-2");
 544 //                      Assert.IsTrue (r.Instance is StaticExtension, "#26");
 545
 546                         if (r is XamlXmlReader)
 547                                 ReadBase (r);
 548
 549                         Assert.IsTrue (r.Read (), "#31");
 550                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 551                         Assert.AreEqual (ctorArgMember, r.Member, "#33-2");
 552
 553                         Assert.IsTrue (r.Read (), "#41");
 554                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 555                         Assert.AreEqual ("FooBar", r.Value, "#43-2");
 556
 557                         Assert.IsTrue (r.Read (), "#51");
 558                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 559
 560                         Assert.IsTrue (r.Read (), "#61");
 561                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 562
 563                         Assert.IsFalse (r.Read (), "#71");
 564                         Assert.IsTrue (r.IsEof, "#72");
 565                 }
 566
 567                 protected void Read_ListInt32 (XamlReader r, Action validateInstance, List<int> obj)
 568                 {
 569                         Assert.IsTrue (r.Read (), "ns#1-1");
 570                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
 571
 572                         var defns = "clr-namespace:System.Collections.Generic;assembly=mscorlib";
 573
 574                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3");
 575                         Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4");
 576
 577                         Assert.IsTrue (r.Read (), "#11");
 578                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 579                         Assert.IsNotNull (r.Namespace, "#13");
 580                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 581                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 582
 583                         Assert.IsTrue (r.Read (), "#21");
 584                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 585                         var xt = new XamlType (typeof (List<int>), r.SchemaContext);
 586                         Assert.AreEqual (xt, r.Type, "#23");
 587                         Assert.IsTrue (xt.IsCollection, "#27");
 588                         if (validateInstance != null)
 589                                 validateInstance ();
 590
 591                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 592
 593                         if (r is XamlXmlReader)
 594                                 ReadBase (r);
 595
 596                         Assert.IsTrue (r.Read (), "#31");
 597                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 598                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
 599
 600                         Assert.IsTrue (r.Read (), "#41");
 601                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 602                         // The value is implementation details, not testable.
 603                         //Assert.AreEqual ("3", r.Value, "#43");
 604
 605                         Assert.IsTrue (r.Read (), "#51");
 606                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 607
 608                         if (obj.Count > 0) { // only when items exist.
 609
 610                         Assert.IsTrue (r.Read (), "#72");
 611                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 612                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 613
 614                         string [] values = {"5", "-3", "2147483647", "0"};
 615                         for (int i = 0; i < 4; i++) {
 616                                 Assert.IsTrue (r.Read (), i + "#73");
 617                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 618                                 Assert.IsTrue (r.Read (), i + "#74");
 619                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 620                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 621                                 Assert.IsTrue (r.Read (), i + "#75");
 622                                 Assert.IsNotNull (r.Value, i + "#75-2");
 623                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 624                                 Assert.IsTrue (r.Read (), i + "#74");
 625                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 626                                 Assert.IsTrue (r.Read (), i + "#75");
 627                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 628                         }
 629
 630                         Assert.IsTrue (r.Read (), "#81");
 631                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 632
 633                         } // end of "if count > 0".
 634
 635                         Assert.IsTrue (r.Read (), "#87");
 636                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88");
 637
 638                         Assert.IsFalse (r.Read (), "#89");
 639                 }
 640
 641                 protected void Read_ArrayList (XamlReader r)
 642                 {
 643                         Assert.IsTrue (r.Read (), "ns#1-1");
 644                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
 645
 646                         var defns = "clr-namespace:System.Collections;assembly=mscorlib";
 647
 648                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3");
 649                         Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4");
 650
 651                         Assert.IsTrue (r.Read (), "#11");
 652                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 653                         Assert.IsNotNull (r.Namespace, "#13");
 654                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 655                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 656
 657                         Assert.IsTrue (r.Read (), "#21");
 658                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 659                         var xt = new XamlType (typeof (ArrayList), r.SchemaContext);
 660                         Assert.AreEqual (xt, r.Type, "#23");
 661 //                      Assert.AreEqual (obj, r.Instance, "#26");
 662                         Assert.IsTrue (xt.IsCollection, "#27");
 663
 664                         if (r is XamlXmlReader)
 665                                 ReadBase (r);
 666
 667                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 668
 669                         Assert.IsTrue (r.Read (), "#31");
 670                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 671                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
 672
 673                         Assert.IsTrue (r.Read (), "#41");
 674                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 675                         // The value is implementation details, not testable.
 676                         //Assert.AreEqual ("3", r.Value, "#43");
 677
 678                         Assert.IsTrue (r.Read (), "#51");
 679                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 680
 681                         Assert.IsTrue (r.Read (), "#72");
 682                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 683                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 684
 685                         string [] values = {"5", "-3", "0"};
 686                         for (int i = 0; i < 3; i++) {
 687                                 Assert.IsTrue (r.Read (), i + "#73");
 688                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 689                                 Assert.IsTrue (r.Read (), i + "#74");
 690                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 691                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 692                                 Assert.IsTrue (r.Read (), i + "#75");
 693                                 Assert.IsNotNull (r.Value, i + "#75-2");
 694                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 695                                 Assert.IsTrue (r.Read (), i + "#74");
 696                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 697                                 Assert.IsTrue (r.Read (), i + "#75");
 698                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 699                         }
 700
 701                         Assert.IsTrue (r.Read (), "#81");
 702                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 703
 704                         Assert.IsTrue (r.Read (), "#87");
 705                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88");
 706
 707                         Assert.IsFalse (r.Read (), "#89");
 708                 }
 709
 710                 protected void Read_ArrayOrArrayExtensionOrMyArrayExtension (XamlReader r, Action validateInstance, Type extType)
 711                 {
 712                         if (extType == typeof (MyArrayExtension)) {
 713                                 Assert.IsTrue (r.Read (), "#1");
 714                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
 715                                 Assert.IsNotNull (r.Namespace, "#3");
 716                                 Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
 717                         }
 718                         Assert.IsTrue (r.Read (), "#11");
 719                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 720                         Assert.IsNotNull (r.Namespace, "#13");
 721                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 722                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 723
 724                         Assert.IsTrue (r.Read (), "#21");
 725                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 726                         var xt = new XamlType (extType, r.SchemaContext);
 727                         Assert.AreEqual (xt, r.Type, "#23");
 728                         if (validateInstance != null)
 729                                 validateInstance ();
 730
 731                         if (r is XamlXmlReader)
 732                                 ReadBase (r);
 733
 734                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 735
 736                         Assert.IsTrue (r.Read (), "#31");
 737                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 738                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33");
 739
 740                         Assert.IsTrue (r.Read (), "#41");
 741                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 742                         Assert.AreEqual ("x:Int32", r.Value, "#43");
 743
 744                         Assert.IsTrue (r.Read (), "#51");
 745                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 746
 747                         Assert.IsTrue (r.Read (), "#61");
 748                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
 749                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
 750
 751                         Assert.IsTrue (r.Read (), "#71");
 752                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
 753                         Assert.IsNull (r.Type, "#71-3");
 754                         Assert.IsNull (r.Member, "#71-4");
 755                         Assert.IsNull (r.Value, "#71-5");
 756
 757                         Assert.IsTrue (r.Read (), "#72");
 758                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 759                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 760
 761                         string [] values = {"5", "-3", "0"};
 762                         for (int i = 0; i < 3; i++) {
 763                                 Assert.IsTrue (r.Read (), i + "#73");
 764                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 765                                 Assert.IsTrue (r.Read (), i + "#74");
 766                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 767                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 768                                 Assert.IsTrue (r.Read (), i + "#75");
 769                                 Assert.IsNotNull (r.Value, i + "#75-2");
 770                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 771                                 Assert.IsTrue (r.Read (), i + "#74");
 772                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 773                                 Assert.IsTrue (r.Read (), i + "#75");
 774                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 775                         }
 776
 777                         Assert.IsTrue (r.Read (), "#81");
 778                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 779
 780                         Assert.IsTrue (r.Read (), "#83");
 781                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
 782
 783                         Assert.IsTrue (r.Read (), "#85");
 784                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ArrayExtension.Items
 785
 786                         Assert.IsTrue (r.Read (), "#87");
 787                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ArrayExtension
 788
 789                         Assert.IsFalse (r.Read (), "#89");
 790                 }
 791
 792                 // It gives Type member, not PositionalParameters... and no Items member here.
 793                 protected void Read_ArrayExtension2 (XamlReader r)
 794                 {
 795                         Assert.IsTrue (r.Read (), "#11");
 796                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 797                         Assert.IsNotNull (r.Namespace, "#13");
 798                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 799                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 800 //                      Assert.IsNull (r.Instance, "#14");
 801
 802                         Assert.IsTrue (r.Read (), "#21");
 803                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 804                         var xt = new XamlType (typeof (ArrayExtension), r.SchemaContext);
 805                         Assert.AreEqual (xt, r.Type, "#23-2");
 806 //                      Assert.IsTrue (r.Instance is ArrayExtension, "#26");
 807
 808                         if (r is XamlXmlReader)
 809                                 ReadBase (r);
 810
 811                         Assert.IsTrue (r.Read (), "#31");
 812                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 813                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33-2");
 814
 815                         Assert.IsTrue (r.Read (), "#41");
 816                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 817                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 818
 819                         Assert.IsTrue (r.Read (), "#51");
 820                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 821
 822                         Assert.IsTrue (r.Read (), "#61");
 823                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 824
 825                         Assert.IsFalse (r.Read (), "#71");
 826                         Assert.IsTrue (r.IsEof, "#72");
 827                 }
 828         }
 829
 830         public partial class XamlObjectReaderTest
 831         {
 832                 [Test]
 833                 public void Read_String ()
 834                 {
 835                         var r = new XamlObjectReader ("foo");
 836                         Read_String (r);
 837                 }
 838
 839                 [Test]
 840                 public void WriteNullMemberAsObject ()
 841                 {
 842                         var r = new XamlObjectReader (new TestClass4 ());
 843                         WriteNullMemberAsObject (r, delegate {
 844                                 Assert.IsNull (r.Instance, "#x"); }
 845                                 );
 846                 }
 847
 848                 [Test]
 849                 public void StaticMember ()
 850                 {
 851                         var r = new XamlObjectReader (new TestClass5 ());
 852                         StaticMember (r);
 853                 }
 854
 855                 [Test]
 856                 public void Skip ()
 857                 {
 858                         var r = new XamlObjectReader ("Foo");
 859                         Skip (r);
 860                 }
 861
 862                 [Test]
 863                 public void Skip2 ()
 864                 {
 865                         var r = new XamlObjectReader ("Foo");
 866                         Skip2 (r);
 867                 }
 868
 869                 [Test]
 870                 public void Read_XmlDocument ()
 871                 {
 872                         var doc = new XmlDocument ();
 873                         doc.LoadXml ("<root xmlns='urn:foo'><elem attr='val' /></root>");
 874                         var r = new XamlObjectReader (doc);
 875                         Read_XmlDocument (r);
 876                 }
 877
 878                 [Test]
 879                 public void Read_NonPrimitive ()
 880                 {
 881                         var r = new XamlObjectReader (new TestClass3 ());
 882                         Read_NonPrimitive (r);
 883                 }
 884
 885                 [Test]
 886                 public void Read_Type ()
 887                 {
 888                         var r = new XamlObjectReader (typeof (int));
 889                         Read_TypeOrTypeExtension (r);
 890                 }
 891
 892                 [Test]
 893                 public void Read_TypeExtension ()
 894                 {
 895                         var tx = new TypeExtension (typeof (int));
 896                         var r = new XamlObjectReader (tx);
 897                         Read_TypeOrTypeExtension (r);
 898                 }
 899
 900                 void Read_TypeOrTypeExtension (XamlObjectReader r)
 901                 {
 902                         Read_TypeOrTypeExtension (r, delegate {
 903                                 Assert.IsTrue (r.Instance is TypeExtension, "#26");
 904                                 }, XamlLanguage.PositionalParameters);
 905                 }
 906
 907                 [Test]
 908                 public void Read_Type2 ()
 909                 {
 910                         var r = new XamlObjectReader (typeof (TestClass1));
 911                         Read_TypeOrTypeExtension2 (r);
 912                 }
 913
 914                 [Test]
 915                 public void Read_TypeExtension2 ()
 916                 {
 917                         var r = new XamlObjectReader (new TypeExtension (typeof (TestClass1)));
 918                         Read_TypeOrTypeExtension2 (r);
 919                 }
 920
 921                 void Read_TypeOrTypeExtension2 (XamlObjectReader r)
 922                 {
 923                         Read_TypeOrTypeExtension2 (r, delegate {
 924                                 Assert.IsTrue (r.Instance is TypeExtension, "#26");
 925                         }, XamlLanguage.PositionalParameters);
 926                 }
 927
 928                 [Test]
 929                 public void Read_Reference ()
 930                 {
 931                         var r = new XamlObjectReader (new Reference ("FooBar"));
 932                         Read_Reference (r);
 933                 }
 934
 935                 [Test]
 936                 public void Read_Null ()
 937                 {
 938                         var r = new XamlObjectReader (null);
 939                         Read_NullOrNullExtension (r, (object) null);
 940                 }
 941
 942                 [Test]
 943                 public void Read_NullExtension ()
 944                 {
 945                         var o = new NullExtension ();
 946                         var r = new XamlObjectReader (o);
 947                         Read_NullOrNullExtension (r, o);
 948                 }
 949
 950                 void Read_NullOrNullExtension (XamlObjectReader r, object instance)
 951                 {
 952                         Read_NullOrNullExtension (r, delegate {
 953                                 Assert.AreEqual (instance, r.Instance, "#26"); // null and NullExtension are different here.
 954                         });
 955                 }
 956
 957                 [Test]
 958                 public void Read_StaticExtension ()
 959                 {
 960                         var r = new XamlObjectReader (new StaticExtension ("FooBar"));
 961                         Read_StaticExtension (r, XamlLanguage.PositionalParameters);
 962                 }
 963
 964                 [Test]
 965                 public void Read_ListInt32 ()
 966                 {
 967                         var obj = new List<int> (new int [] {5, -3, int.MaxValue, 0});
 968                         Read_ListInt32 (obj);
 969                 }
 970
 971                 [Test]
 972                 public void Read_ListInt32_2 ()
 973                 {
 974                         var obj = new List<int> (new int [0]);
 975                         Read_ListInt32 (obj);
 976                 }
 977
 978                 void Read_ListInt32 (List<int> obj)
 979                 {
 980                         var r = new XamlObjectReader (obj);
 981                         Read_ListInt32 (r, delegate {
 982                                 Assert.AreEqual (obj, r.Instance, "#26");
 983                                 }, obj);
 984                 }
 985
 986                 [Test]
 987                 public void Read_ArrayList ()
 988                 {
 989                         var obj = new ArrayList (new int [] {5, -3, 0});
 990                         var r = new XamlObjectReader (obj);
 991                         Read_ArrayList (r);
 992                 }
 993
 994                 [Test]
 995                 public void Read_Array ()
 996                 {
 997                         var obj = new int [] {5, -3, 0};
 998                         var r = new XamlObjectReader (obj);
 999                         Read_ArrayOrArrayExtension (r, obj);
1000                 }
1001
1002                 [Test]
1003                 public void Read_ArrayExtension ()
1004                 {
1005                         var obj = new ArrayExtension (new int [] {5, -3, 0});
1006                         var r = new XamlObjectReader (obj);
1007                         Read_ArrayOrArrayExtension (r, obj);
1008                 }
1009
1010                 [Test]
1011                 public void Read_MyArrayExtension ()
1012                 {
1013                         var obj = new MyArrayExtension (new int [] {5, -3, 0});
1014                         var r = new XamlObjectReader (obj);
1015                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, obj, typeof (MyArrayExtension));
1016                 }
1017
1018                 void Read_ArrayOrArrayExtension (XamlObjectReader r, object instance)
1019                 {
1020                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, instance, typeof (ArrayExtension));
1021                 }
1022
1023                 void Read_ArrayOrArrayExtensionOrMyArrayExtension (XamlObjectReader r, object instance, Type extType)
1024                 {
1025                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, delegate {
1026                                 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)
1027                                 }, extType);
1028                 }
1029
1030                 [Test]
1031                 public void Read_ArrayExtension2 ()
1032                 {
1033                         var r = new XamlObjectReader (new ArrayExtension (typeof (int)));
1034                         Read_ArrayExtension2 (r);
1035                 }
1036
1037                 [Test]
1038                 public void Read_DateTime ()
1039                 {
1040                         var obj = new DateTime (2010, 4, 15);
1041                         var r = new XamlObjectReader (obj);
1042                         Read_CommonClrType (r, obj);
1043                         Assert.AreEqual ("2010-04-15", Read_Initialization (r, null), "#1");
1044                 }
1045
1046                 [Test]
1047                 public void Read_TimeSpan ()
1048                 {
1049                         Read_CommonXamlPrimitive (TimeSpan.FromMinutes (4));
1050                 }
1051
1052                 [Test]
1053                 public void Read_Uri ()
1054                 {
1055                         Read_CommonXamlPrimitive (new Uri ("urn:foo"));
1056                 }
1057
1058                 [Test]
1059                 public void Read_Guid ()
1060                 {
1061                         var obj = Guid.NewGuid ();
1062                         var r = new XamlObjectReader (obj);
1063                         Assert.IsNotNull (r.SchemaContext.GetXamlType (typeof (Guid)).TypeConverter, "premise#1");
1064                         Read_CommonClrType (r, obj);
1065                         Assert.AreEqual (obj.ToString (), Read_Initialization (r, null), "#1");
1066                 }
1067
1068                 [Test]
1069                 [ExpectedException (typeof (XamlObjectReaderException))]
1070                 [Category ("NotWorking")]
1071                 public void Read_XData ()
1072                 {
1073                         var r = new XamlObjectReader (new XData () {Text = "xdata text"}); // XmlReader implementation is not visible.
1074                         while (!r.IsEof)
1075                                 r.Read ();
1076                 }
1077
1078                 [Test]
1079                 public void ReadStandardTypes ()
1080                 {
1081                         SimpleReadStandardType (new ArrayExtension ());
1082                         SimpleReadStandardType (new NullExtension ());
1083                         SimpleReadStandardType (new PropertyDefinition ());
1084                         SimpleReadStandardType (new Reference ());
1085                         SimpleReadStandardType (new StaticExtension ());
1086                         SimpleReadStandardType (new TypeExtension ());
1087                 }
1088
1089                 void SimpleReadStandardType (object instance)
1090                 {
1091                         var r = new XamlObjectReader (instance);
1092                         while (!r.IsEof)
1093                                 r.Read ();
1094                 }
1095
1096                 [Test]
1097                 public void Read_CustomMarkupExtension ()
1098                 {
1099                         var r = new XamlObjectReader (new MyExtension () { Foo = typeof (int), Bar = "v2", Baz = "v7"});
1100                         Read_CustomMarkupExtension (r);
1101                 }
1102
1103                 [Test]
1104                 public void Read_CustomMarkupExtension2 ()
1105                 {
1106                         var r = new XamlObjectReader (new MyExtension2 () { Foo = typeof (int), Bar = "v2"});
1107                         Read_CustomMarkupExtension2 (r);
1108                 }
1109
1110                 [Test]
1111                 public void Read_CustomMarkupExtension3 ()
1112                 {
1113                         var r = new XamlObjectReader (new MyExtension3 () { Foo = typeof (int), Bar = "v2"});
1114                         Read_CustomMarkupExtension3 (r);
1115                 }
1116
1117                 [Test]
1118                 public void Read_CustomMarkupExtension4 ()
1119                 {
1120                         var r = new XamlObjectReader (new MyExtension4 () { Foo = typeof (int), Bar = "v2"});
1121                         Read_CustomMarkupExtension4 (r);
1122                 }
1123
1124                 [Test]
1125                 public void Read_CustomMarkupExtension5 ()
1126                 {
1127                         // This cannot be written to XamlXmlWriter though...
1128
1129                         var r = new XamlObjectReader (new MyExtension5 ("foo", "bar"));
1130                         Read_CustomMarkupExtension5 (r);
1131                 }
1132
1133                 [Test]
1134                 public void Read_CustomMarkupExtension6 ()
1135                 {
1136                         var r = new XamlObjectReader (new MyExtension6 ("foo"));
1137                         Read_CustomMarkupExtension6 (r);
1138                 }
1139
1140                 [Test]
1141                 public void Read_ArgumentAttributed ()
1142                 {
1143                         var obj = new ArgumentAttributed ("foo", "bar");
1144                         var r = new XamlObjectReader (obj);
1145                         Read_ArgumentAttributed (r, obj);
1146                 }
1147         }
1148
1149         public partial class XamlReaderTestBase
1150         {
1151                 protected void Read_CustomMarkupExtension (XamlReader r)
1152                 {
1153                         r.Read (); // ns
1154                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1155                         r.Read (); // ns
1156                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-2");
1157                         r.Read ();
1158                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1159                         Assert.IsFalse (r.IsEof, "#1");
1160                         var xt = r.Type;
1161
1162                         if (r is XamlXmlReader)
1163                                 ReadBase (r);
1164
1165                         r.Read ();
1166                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#2-1");
1167                         Assert.IsFalse (r.IsEof, "#2-2");
1168                         Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#2-3");
1169
1170                         Assert.IsTrue (r.Read (), "#2-4");
1171                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#2-5");
1172                         Assert.AreEqual ("v2", r.Value, "#2-6");
1173
1174                         Assert.IsTrue (r.Read (), "#2-7");
1175                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#2-8");
1176
1177                         r.Read ();
1178                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-1");
1179                         Assert.IsFalse (r.IsEof, "#3-2");
1180                         Assert.AreEqual (xt.GetMember ("Baz"), r.Member, "#3-3");
1181
1182                         Assert.IsTrue (r.Read (), "#3-4");
1183                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#3-5");
1184                         Assert.AreEqual ("v7", r.Value, "#3-6");
1185
1186                         Assert.IsTrue (r.Read (), "#3-7");
1187                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#3-8");
1188
1189                         r.Read ();
1190                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#4-1");
1191                         Assert.IsFalse (r.IsEof, "#4-2");
1192                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4-3");
1193                         Assert.IsTrue (r.Read (), "#4-4");
1194                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#4-5");
1195                         Assert.AreEqual ("x:Int32", r.Value, "#4-6");
1196
1197                         Assert.IsTrue (r.Read (), "#4-7");
1198                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#4-8");
1199
1200                         Assert.IsTrue (r.Read (), "#5");
1201                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#5-2");
1202
1203                         Assert.IsFalse (r.Read (), "#6");
1204                 }
1205
1206                 protected void Read_CustomMarkupExtension2 (XamlReader r)
1207                 {
1208                         r.Read (); // ns
1209                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1210                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1211                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1212                         var xt = r.Type;
1213                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension2)), xt, "#2");
1214
1215                         if (r is XamlXmlReader)
1216                                 ReadBase (r);
1217
1218                         Assert.IsTrue (r.Read (), "#3");
1219                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1220                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1221                         Assert.IsTrue (r.Read (), "#5");
1222                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension2", r.Value, "#6");
1223                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1224                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1225                         Assert.IsFalse (r.Read (), "#9");
1226                 }
1227
1228                 protected void Read_CustomMarkupExtension3 (XamlReader r)
1229                 {
1230                         r.Read (); // ns
1231                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1232                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1233                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1234                         var xt = r.Type;
1235                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension3)), xt, "#2");
1236
1237                         if (r is XamlXmlReader)
1238                                 ReadBase (r);
1239
1240                         Assert.IsTrue (r.Read (), "#3");
1241                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1242                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1243                         Assert.IsTrue (r.Read (), "#5");
1244                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension3", r.Value, "#6");
1245                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1246                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1247                         Assert.IsFalse (r.Read (), "#9");
1248                 }
1249
1250                 protected void Read_CustomMarkupExtension4 (XamlReader r)
1251                 {
1252                         r.Read (); // ns
1253                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1254                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1255                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1256                         var xt = r.Type;
1257                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension4)), xt, "#2");
1258
1259                         if (r is XamlXmlReader)
1260                                 ReadBase (r);
1261
1262                         Assert.IsTrue (r.Read (), "#3");
1263                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1264                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1265                         Assert.IsTrue (r.Read (), "#5");
1266                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension4", r.Value, "#6");
1267                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1268                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1269                         Assert.IsFalse (r.Read (), "#9");
1270                 }
1271
1272                 protected void Read_CustomMarkupExtension5 (XamlReader r)
1273                 {
1274                         r.Read (); // ns
1275                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1276                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1277                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1278                         var xt = r.Type;
1279                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension5)), xt, "#2");
1280
1281                         if (r is XamlXmlReader)
1282                                 ReadBase (r);
1283
1284                         Assert.IsTrue (r.Read (), "#3");
1285                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1286                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#4");
1287                         Assert.IsTrue (r.Read (), "#5");
1288                         Assert.AreEqual ("foo", r.Value, "#6");
1289                         Assert.IsTrue (r.Read (), "#7");
1290                         Assert.AreEqual ("bar", r.Value, "#8");
1291                         Assert.IsTrue (r.Read (), "#9");
1292                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#10");
1293                         Assert.IsTrue (r.Read (), "#11");
1294                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#12");
1295                         Assert.IsFalse (r.Read (), "#13");
1296                 }
1297
1298                 protected void Read_CustomMarkupExtension6 (XamlReader r)
1299                 {
1300                         r.Read (); // ns
1301                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1302                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1303                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1304                         var xt = r.Type;
1305                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension6)), xt, "#2");
1306
1307                         if (r is XamlXmlReader)
1308                                 ReadBase (r);
1309
1310                         Assert.IsTrue (r.Read (), "#3");
1311                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1312                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4"); // this is the difference between MyExtension5 and MyExtension6: it outputs constructor arguments as normal members
1313                         Assert.IsTrue (r.Read (), "#5");
1314                         Assert.AreEqual ("foo", r.Value, "#6");
1315                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1316                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1317                         Assert.IsFalse (r.Read (), "#9");
1318                 }
1319
1320                 protected void Read_ArgumentAttributed (XamlReader r, object obj)
1321                 {
1322                         Read_CommonClrType (r, obj, new KeyValuePair<string,string> ("x", XamlLanguage.Xaml2006Namespace));
1323
1324                         if (r is XamlXmlReader)
1325                                 ReadBase (r);
1326
1327                         var args = Read_AttributedArguments_String (r, new string [] {"arg1", "arg2"});
1328                         Assert.AreEqual ("foo", args [0], "#1");
1329                         Assert.AreEqual ("bar", args [1], "#2");
1330                 }
1331
1332                 protected void Read_Dictionary (XamlReader r)
1333                 {
1334                         Assert.IsTrue (r.Read (), "ns#1-1");
1335                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1336                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1337                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1338                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "ns#1-5");
1339
1340                         Assert.IsTrue (r.Read (), "ns#2-1");
1341                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1342                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1343                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1344                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1345
1346                         Assert.IsTrue (r.Read (), "so#1-1");
1347                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1348                         var xt = new XamlType (typeof (Dictionary<string,object>), r.SchemaContext);
1349                         Assert.AreEqual (xt, r.Type, "so#1-3");
1350 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1351
1352                         if (r is XamlXmlReader)
1353                                 ReadBase (r);
1354
1355                         Assert.IsTrue (r.Read (), "smitems#1");
1356                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smitems#2");
1357                         Assert.AreEqual (XamlLanguage.Items, r.Member, "smitems#3");
1358
1359                         for (int i = 0; i < 2; i++) {
1360
1361                                 // start of an item
1362                                 Assert.IsTrue (r.Read (), "soi#1-1." + i);
1363                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "soi#1-2." + i);
1364                                 var xt2 = new XamlType (typeof (double), r.SchemaContext);
1365                                 Assert.AreEqual (xt2, r.Type, "soi#1-3." + i);
1366
1367                                 Assert.IsTrue (r.Read (), "smi#1-1." + i);
1368                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#1-2." + i);
1369                                 Assert.AreEqual (XamlLanguage.Key, r.Member, "smi#1-3." + i);
1370
1371                                 Assert.IsTrue (r.Read (), "svi#1-1." + i);
1372                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#1-2." + i);
1373                                 Assert.AreEqual (i == 0 ? "Foo" : "Bar", r.Value, "svi#1-3." + i);
1374
1375                                 Assert.IsTrue (r.Read (), "emi#1-1." + i);
1376                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#1-2." + i);
1377
1378                                 Assert.IsTrue (r.Read (), "smi#2-1." + i);
1379                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#2-2." + i);
1380                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, "smi#2-3." + i);
1381
1382                                 Assert.IsTrue (r.Read (), "svi#2-1." + i);
1383                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#2-2." + i);
1384                                 Assert.AreEqual (i == 0 ? "5" : "-6.5", r.Value, "svi#2-3." + i); // converted to string(!)
1385
1386                                 Assert.IsTrue (r.Read (), "emi#2-1." + i);
1387                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#2-2." + i);
1388
1389                                 Assert.IsTrue (r.Read (), "eoi#1-1." + i);
1390                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eoi#1-2." + i);
1391                                 // end of an item
1392                         }
1393
1394                         Assert.IsTrue (r.Read (), "emitems#1");
1395                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emitems#2"); // XamlLanguage.Items
1396
1397                         Assert.IsTrue (r.Read (), "eo#1-1");
1398                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2"); // Dictionary
1399
1400                         Assert.IsFalse (r.Read (), "end");
1401                 }
1402
1403                 protected void Read_Dictionary2 (XamlReader r, XamlMember ctorArgMember)
1404                 {
1405                         Assert.IsTrue (r.Read (), "ns#1-1");
1406                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1407                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1408                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1409                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "ns#1-5");
1410
1411                         Assert.IsTrue (r.Read (), "ns#2-1");
1412                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1413                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1414                         Assert.AreEqual ("s", r.Namespace.Prefix, "ns#2-4");
1415                         Assert.AreEqual ("clr-namespace:System;assembly=mscorlib", r.Namespace.Namespace, "ns#2-5");
1416
1417                         Assert.IsTrue (r.Read (), "ns#3-1");
1418                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#3-2");
1419                         Assert.IsNotNull (r.Namespace, "ns#3-3");
1420                         Assert.AreEqual ("sx", r.Namespace.Prefix, "ns#3-4");
1421                         Assert.AreEqual ("clr-namespace:System.Xaml;assembly=System.Xaml", r.Namespace.Namespace, "ns#3-5");
1422
1423                         Assert.IsTrue (r.Read (), "ns#4-1");
1424                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#4-2");
1425                         Assert.IsNotNull (r.Namespace, "ns#4-3");
1426                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#4-4");
1427                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#4-5");
1428
1429                         Assert.IsTrue (r.Read (), "so#1-1");
1430                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1431                         var xt = new XamlType (typeof (Dictionary<string,Type>), r.SchemaContext);
1432                         Assert.AreEqual (xt, r.Type, "so#1-3");
1433 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1434
1435                         if (r is XamlXmlReader)
1436                                 ReadBase (r);
1437
1438                         Assert.IsTrue (r.Read (), "smitems#1");
1439                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smitems#2");
1440                         Assert.AreEqual (XamlLanguage.Items, r.Member, "smitems#3");
1441
1442                         for (int i = 0; i < 2; i++) {
1443
1444                                 // start of an item
1445                                 Assert.IsTrue (r.Read (), "soi#1-1." + i);
1446                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "soi#1-2." + i);
1447                                 var xt2 = XamlLanguage.Type;
1448                                 Assert.AreEqual (xt2, r.Type, "soi#1-3." + i);
1449
1450                                 if (r is XamlObjectReader) {
1451                                         Read_Dictionary2_ConstructorArgument (r, ctorArgMember, i);
1452                                         Read_Dictionary2_Key (r, i);
1453                                 } else {
1454                                         Read_Dictionary2_Key (r, i);
1455                                         Read_Dictionary2_ConstructorArgument (r, ctorArgMember, i);
1456                                 }
1457
1458                                 Assert.IsTrue (r.Read (), "eoi#1-1." + i);
1459                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eoi#1-2." + i);
1460                                 // end of an item
1461                         }
1462
1463                         Assert.IsTrue (r.Read (), "emitems#1");
1464                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emitems#2"); // XamlLanguage.Items
1465
1466                         Assert.IsTrue (r.Read (), "eo#1-1");
1467                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2"); // Dictionary
1468
1469                         Assert.IsFalse (r.Read (), "end");
1470                 }
1471
1472                 void Read_Dictionary2_ConstructorArgument (XamlReader r, XamlMember ctorArgMember, int i)
1473                 {
1474                         Assert.IsTrue (r.Read (), "smi#1-1." + i);
1475                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#1-2." + i);
1476                         Assert.AreEqual (ctorArgMember, r.Member, "smi#1-3." + i);
1477
1478                         Assert.IsTrue (r.Read (), "svi#1-1." + i);
1479                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#1-2." + i);
1480                         Assert.AreEqual (i == 0 ? "x:Int32" : "Dictionary(s:Type, sx:XamlType)", r.Value, "svi#1-3." + i);
1481
1482                         Assert.IsTrue (r.Read (), "emi#1-1." + i);
1483                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#1-2." + i);
1484                 }
1485
1486                 void Read_Dictionary2_Key (XamlReader r, int i)
1487                 {
1488                         Assert.IsTrue (r.Read (), "smi#2-1." + i);
1489                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#2-2." + i);
1490                         Assert.AreEqual (XamlLanguage.Key, r.Member, "smi#2-3." + i);
1491
1492                         Assert.IsTrue (r.Read (), "svi#2-1." + i);
1493                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#2-2." + i);
1494                         Assert.AreEqual (i == 0 ? "Foo" : "Bar", r.Value, "svi#2-3." + i);
1495
1496                         Assert.IsTrue (r.Read (), "emi#2-1." + i);
1497                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#2-2." + i);
1498                 }
1499
1500                 protected void PositionalParameters1 (XamlReader r)
1501                 {
1502                         // ns1 > T:PositionalParametersClass1 > M:_PositionalParameters > foo > 5 > EM:_PositionalParameters > ET:PositionalParametersClass1
1503
1504                         Assert.IsTrue (r.Read (), "ns#1-1");
1505                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1506                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1507                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1508                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1509
1510                         Assert.IsTrue (r.Read (), "so#1-1");
1511                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1512                         var xt = new XamlType (typeof (PositionalParametersClass1), r.SchemaContext);
1513                         Assert.AreEqual (xt, r.Type, "so#1-3");
1514 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1515
1516                         if (r is XamlXmlReader)
1517                                 ReadBase (r);
1518
1519                         Assert.IsTrue (r.Read (), "sposprm#1");
1520                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1521                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "sposprm#3");
1522
1523                         Assert.IsTrue (r.Read (), "sva#1-1");
1524                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1525                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1526
1527                         Assert.IsTrue (r.Read (), "sva#2-1");
1528                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#2-2");
1529                         Assert.AreEqual ("5", r.Value, "sva#2-3");
1530
1531                         Assert.IsTrue (r.Read (), "eposprm#1");
1532                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2"); // XamlLanguage.PositionalParameters
1533
1534                         Assert.IsTrue (r.Read (), "eo#1-1");
1535                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1536
1537                         Assert.IsFalse (r.Read (), "end");
1538                 }
1539
1540                 protected void PositionalParameters2 (XamlReader r)
1541                 {
1542                         // ns1 > T:PositionalParametersWrapper > M:Body > T:PositionalParametersClass1 > M:_PositionalParameters > foo > 5 > EM:_PositionalParameters > ET:PositionalParametersClass1
1543
1544                         Assert.IsTrue (r.Read (), "ns#1-1");
1545                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1546                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1547                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1548                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1549
1550                         Assert.IsTrue (r.Read (), "so#1-1");
1551                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1552                         var xt = new XamlType (typeof (PositionalParametersWrapper), r.SchemaContext);
1553                         Assert.AreEqual (xt, r.Type, "so#1-3");
1554 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1555
1556                         if (r is XamlXmlReader)
1557                                 ReadBase (r);
1558
1559                         Assert.IsTrue (r.Read (), "sm#1-1");
1560                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#1-2");
1561                         Assert.AreEqual (xt.GetMember ("Body"), r.Member, "sm#1-3");
1562
1563                         xt = new XamlType (typeof (PositionalParametersClass1), r.SchemaContext);
1564                         Assert.IsTrue (r.Read (), "so#2-1");
1565                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1566                         Assert.AreEqual (xt, r.Type, "so#2-3");
1567 //                      Assert.AreEqual (obj.Body, r.Instance, "so#2-4");
1568
1569                         Assert.IsTrue (r.Read (), "sposprm#1");
1570                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1571                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "sposprm#3");
1572
1573                         Assert.IsTrue (r.Read (), "sva#1-1");
1574                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1575                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1576
1577                         Assert.IsTrue (r.Read (), "sva#2-1");
1578                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#2-2");
1579                         Assert.AreEqual ("5", r.Value, "sva#2-3");
1580
1581                         Assert.IsTrue (r.Read (), "eposprm#1");
1582                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2"); // XamlLanguage.PositionalParameters
1583
1584                         Assert.IsTrue (r.Read (), "eo#2-1");
1585                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1586
1587                         Assert.IsTrue (r.Read (), "em#1-1");
1588                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eo#1-2");
1589
1590                         Assert.IsTrue (r.Read (), "eo#1-1");
1591                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1592
1593                         Assert.IsFalse (r.Read (), "end");
1594                 }
1595
1596                 protected void ComplexPositionalParameters (XamlReader r)
1597                 {
1598                         Assert.IsTrue (r.Read (), "ns#1-1");
1599                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1600                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1601                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1602                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1603
1604                         Assert.IsTrue (r.Read (), "ns#2-1");
1605                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1606                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1607                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1608                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1609
1610                         Assert.IsTrue (r.Read (), "so#1-1");
1611                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1612                         var xt = new XamlType (typeof (ComplexPositionalParameterWrapper), r.SchemaContext);
1613                         Assert.AreEqual (xt, r.Type, "so#1-3");
1614 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1615
1616                         if (r is XamlXmlReader)
1617                                 ReadBase (r);
1618
1619                         Assert.IsTrue (r.Read (), "sm#1-1");
1620                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#1-2");
1621                         Assert.AreEqual (xt.GetMember ("Param"), r.Member, "sm#1-3");
1622
1623                         xt = r.SchemaContext.GetXamlType (typeof (ComplexPositionalParameterClass));
1624                         Assert.IsTrue (r.Read (), "so#2-1");
1625                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1626                         Assert.AreEqual (xt, r.Type, "so#2-3");
1627 //                      Assert.AreEqual (obj.Param, r.Instance, "so#2-4");
1628
1629                         Assert.IsTrue (r.Read (), "sarg#1");
1630                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sarg#2");
1631                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "sarg#3");
1632
1633                         Assert.IsTrue (r.Read (), "so#3-1");
1634                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#3-2");
1635                         xt = r.SchemaContext.GetXamlType (typeof (ComplexPositionalParameterValue));
1636                         Assert.AreEqual (xt, r.Type, "so#3-3");
1637
1638                         Assert.IsTrue (r.Read (), "sm#3-1");
1639                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#3-2");
1640                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "sm#3-3");
1641                         Assert.IsTrue (r.Read (), "v#3-1");
1642                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "v#3-2");
1643                         Assert.AreEqual ("foo", r.Value, "v#3-3");
1644
1645                         Assert.IsTrue (r.Read (), "em#3-1");
1646                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em#3-2");
1647                         Assert.IsTrue (r.Read (), "eo#3-1");
1648                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#3-2");
1649
1650                         Assert.IsTrue (r.Read (), "earg#1");
1651                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "earg#2"); // XamlLanguage.Arguments
1652
1653                         Assert.IsTrue (r.Read (), "eo#2-1");
1654                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1655
1656                         Assert.IsTrue (r.Read (), "em#1-1");
1657                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eo#1-2");
1658
1659                         Assert.IsTrue (r.Read (), "eo#1-1");
1660                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1661
1662                         Assert.IsFalse (r.Read (), "end");
1663                 }
1664
1665                 protected void Read_ListWrapper (XamlReader r)
1666                 {
1667                         Assert.IsTrue (r.Read (), "#1");
1668                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
1669                         Assert.IsNotNull (r.Namespace, "#3");
1670                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
1671
1672                         Assert.IsTrue (r.Read (), "#11");
1673                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
1674                         Assert.IsNotNull (r.Namespace, "#13");
1675                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
1676                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
1677
1678                         Assert.IsTrue (r.Read (), "#21");
1679                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
1680                         var xt = new XamlType (typeof (ListWrapper), r.SchemaContext);
1681                         Assert.AreEqual (xt, r.Type, "#23");
1682 //                      Assert.AreEqual (obj, r.Instance, "#26");
1683
1684                         if (r is XamlXmlReader)
1685                                 ReadBase (r);
1686
1687                         Assert.IsTrue (r.Read (), "#61");
1688                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
1689                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
1690
1691                         Assert.IsTrue (r.Read (), "#71");
1692                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
1693                         Assert.IsNull (r.Type, "#71-3");
1694                         Assert.IsNull (r.Member, "#71-4");
1695                         Assert.IsNull (r.Value, "#71-5");
1696
1697                         Assert.IsTrue (r.Read (), "#72");
1698                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
1699                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
1700
1701                         string [] values = {"5", "-3", "0"};
1702                         for (int i = 0; i < 3; i++) {
1703                                 Assert.IsTrue (r.Read (), i + "#73");
1704                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
1705                                 Assert.IsTrue (r.Read (), i + "#74");
1706                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
1707                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
1708                                 Assert.IsTrue (r.Read (), i + "#75");
1709                                 Assert.IsNotNull (r.Value, i + "#75-2");
1710                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
1711                                 Assert.IsTrue (r.Read (), i + "#74");
1712                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
1713                                 Assert.IsTrue (r.Read (), i + "#75");
1714                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
1715                         }
1716
1717                         Assert.IsTrue (r.Read (), "#81");
1718                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
1719
1720                         Assert.IsTrue (r.Read (), "#83");
1721                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
1722
1723                         Assert.IsTrue (r.Read (), "#85");
1724                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ListWrapper.Items
1725
1726                         Assert.IsTrue (r.Read (), "#87");
1727                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ListWrapper
1728
1729                         Assert.IsFalse (r.Read (), "#89");
1730                 }
1731
1732                 protected void Read_ListWrapper2 (XamlReader r)
1733                 {
1734                         Assert.IsTrue (r.Read (), "#1");
1735                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
1736                         Assert.IsNotNull (r.Namespace, "#3");
1737                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
1738
1739                         Assert.IsTrue (r.Read (), "#6");
1740                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
1741                         Assert.IsNotNull (r.Namespace, "#8");
1742                         Assert.AreEqual ("scg", r.Namespace.Prefix, "#8-2");
1743                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "#8-3");
1744
1745                         Assert.IsTrue (r.Read (), "#11");
1746                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
1747                         Assert.IsNotNull (r.Namespace, "#13");
1748                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
1749                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
1750
1751                         Assert.IsTrue (r.Read (), "#21");
1752                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
1753                         var xt = new XamlType (typeof (ListWrapper2), r.SchemaContext);
1754                         Assert.AreEqual (xt, r.Type, "#23");
1755 //                      Assert.AreEqual (obj, r.Instance, "#26");
1756
1757                         if (r is XamlXmlReader)
1758                                 ReadBase (r);
1759
1760                         Assert.IsTrue (r.Read (), "#61");
1761                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
1762                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
1763
1764                         Assert.IsTrue (r.Read (), "#71");
1765                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#71-2");
1766                         xt = r.SchemaContext.GetXamlType (typeof (List<int>));
1767                         Assert.AreEqual (xt, r.Type, "#71-3");
1768                         Assert.IsNull (r.Member, "#71-4");
1769                         Assert.IsNull (r.Value, "#71-5");
1770
1771                         // Capacity
1772                         Assert.IsTrue (r.Read (), "#31");
1773                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
1774                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
1775
1776                         Assert.IsTrue (r.Read (), "#41");
1777                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
1778                         // The value is implementation details, not testable.
1779                         //Assert.AreEqual ("3", r.Value, "#43");
1780
1781                         Assert.IsTrue (r.Read (), "#51");
1782                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
1783
1784                         // Items
1785                         Assert.IsTrue (r.Read (), "#72");
1786                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
1787                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
1788
1789                         string [] values = {"5", "-3", "0"};
1790                         for (int i = 0; i < 3; i++) {
1791                                 Assert.IsTrue (r.Read (), i + "#73");
1792                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
1793                                 Assert.IsTrue (r.Read (), i + "#74");
1794                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
1795                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
1796                                 Assert.IsTrue (r.Read (), i + "#75");
1797                                 Assert.IsNotNull (r.Value, i + "#75-2");
1798                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
1799                                 Assert.IsTrue (r.Read (), i + "#74");
1800                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
1801                                 Assert.IsTrue (r.Read (), i + "#75");
1802                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
1803                         }
1804
1805                         Assert.IsTrue (r.Read (), "#81");
1806                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
1807
1808                         Assert.IsTrue (r.Read (), "#83");
1809                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // StartObject(of List<int>)
1810
1811                         Assert.IsTrue (r.Read (), "#85");
1812                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ListWrapper.Items
1813
1814                         Assert.IsTrue (r.Read (), "#87");
1815                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ListWrapper
1816
1817                         Assert.IsFalse (r.Read (), "#89");
1818                 }
1819
1820                 protected void Read_ContentIncluded (XamlReader r)
1821                 {
1822                         Assert.IsTrue (r.Read (), "ns#1-1");
1823                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1824                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1825                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1826                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1827
1828                         Assert.IsTrue (r.Read (), "so#1-1");
1829                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1830                         var xt = new XamlType (typeof (ContentIncludedClass), r.SchemaContext);
1831                         Assert.AreEqual (xt, r.Type, "so#1-3");
1832
1833                         if (r is XamlXmlReader)
1834                                 ReadBase (r);
1835
1836                         Assert.IsTrue (r.Read (), "sposprm#1");
1837                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1838                         Assert.AreEqual (xt.GetMember ("Content"), r.Member, "sposprm#3");
1839
1840                         Assert.IsTrue (r.Read (), "sva#1-1");
1841                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1842                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1843
1844                         Assert.IsTrue (r.Read (), "eposprm#1");
1845                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2");
1846
1847                         Assert.IsTrue (r.Read (), "eo#1-1");
1848                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1849
1850                         Assert.IsFalse (r.Read (), "end");
1851                 }
1852
1853                 protected void Read_PropertyDefinition (XamlReader r)
1854                 {
1855                         Assert.IsTrue (r.Read (), "ns#1-1");
1856                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1857                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1858                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#1-4");
1859                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#1-5");
1860
1861                         Assert.IsTrue (r.Read (), "so#1-1");
1862                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1863                         var xt = new XamlType (typeof (PropertyDefinition), r.SchemaContext);
1864                         Assert.AreEqual (xt, r.Type, "so#1-3");
1865
1866                         if (r is XamlXmlReader)
1867                                 ReadBase (r);
1868
1869                         Assert.IsTrue (r.Read (), "smod#1");
1870                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smod#2");
1871                         Assert.AreEqual (xt.GetMember ("Modifier"), r.Member, "smod#3");
1872
1873                         Assert.IsTrue (r.Read (), "vmod#1");
1874                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vmod#2");
1875                         Assert.AreEqual ("protected", r.Value, "vmod#3");
1876
1877                         Assert.IsTrue (r.Read (), "emod#1");
1878                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emod#2");
1879
1880                         Assert.IsTrue (r.Read (), "sname#1");
1881                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sname#2");
1882                         Assert.AreEqual (xt.GetMember ("Name"), r.Member, "sname#3");
1883
1884                         Assert.IsTrue (r.Read (), "vname#1");
1885                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vname#2");
1886                         Assert.AreEqual ("foo", r.Value, "vname#3");
1887
1888                         Assert.IsTrue (r.Read (), "ename#1");
1889                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "ename#2");
1890
1891                         Assert.IsTrue (r.Read (), "stype#1");
1892                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "stype#2");
1893                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "stype#3");
1894
1895                         Assert.IsTrue (r.Read (), "vtype#1");
1896                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vtype#2");
1897                         Assert.AreEqual ("x:String", r.Value, "vtype#3");
1898
1899                         Assert.IsTrue (r.Read (), "etype#1");
1900                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "etype#2");
1901
1902                         Assert.IsTrue (r.Read (), "eo#1-1");
1903                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1904
1905                         Assert.IsFalse (r.Read (), "end");
1906                 }
1907
1908                 protected void Read_CommonXamlPrimitive (object obj)
1909                 {
1910                         var r = new XamlObjectReader (obj);
1911                         Read_CommonXamlType (r);
1912                         Read_Initialization (r, obj);
1913                 }
1914
1915                 // from StartMember of Initialization to EndMember
1916                 protected string Read_Initialization (XamlReader r, object comparableValue)
1917                 {
1918                         Assert.IsTrue (r.Read (), "init#1");
1919                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "init#2");
1920                         Assert.IsNotNull (r.Member, "init#3");
1921                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "init#3-2");
1922                         Assert.IsTrue (r.Read (), "init#4");
1923                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "init#5");
1924                         Assert.AreEqual (typeof (string), r.Value.GetType (), "init#6");
1925                         string ret = (string) r.Value;
1926                         if (comparableValue != null)
1927                                 Assert.AreEqual (comparableValue.ToString (), r.Value, "init#6-2");
1928                         Assert.IsTrue (r.Read (), "init#7");
1929                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "init#8");
1930                         return ret;
1931                 }
1932
1933                 protected object [] Read_AttributedArguments_String (XamlReader r, string [] argNames) // valid only for string arguments.
1934                 {
1935                         object [] ret = new object [argNames.Length];
1936
1937                         Assert.IsTrue (r.Read (), "attarg.Arguments.Start1");
1938                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.Arguments.Start2");
1939                         Assert.IsNotNull (r.Member, "attarg.Arguments.Start3");
1940                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "attarg.Arguments.Start4");
1941                         for (int i = 0; i < argNames.Length; i++) {
1942                                 string arg = argNames [i];
1943                                 Assert.IsTrue (r.Read (), "attarg.ArgStartObject1." + arg);
1944                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "attarg.ArgStartObject2." + arg);
1945                                 Assert.AreEqual (typeof (string), r.Type.UnderlyingType, "attarg.ArgStartObject3." + arg);
1946                                 Assert.IsTrue (r.Read (), "attarg.ArgStartMember1." + arg);
1947                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.ArgStartMember2." + arg);
1948                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, "attarg.ArgStartMember3." + arg); // (as the argument is string here by definition)
1949                                 Assert.IsTrue (r.Read (), "attarg.ArgValue1." + arg);
1950                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "attarg.ArgValue2." + arg);
1951                                 Assert.AreEqual (typeof (string), r.Value.GetType (), "attarg.ArgValue3." + arg);
1952                                 ret [i] = r.Value;
1953                                 Assert.IsTrue (r.Read (), "attarg.ArgEndMember1." + arg);
1954                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.ArgEndMember2." + arg);
1955                                 Assert.IsTrue (r.Read (), "attarg.ArgEndObject1." + arg);
1956                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "attarg.ArgEndObject2." + arg);
1957                         }
1958                         Assert.IsTrue (r.Read (), "attarg.Arguments.End1");
1959                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.Arguments.End2");
1960                         return ret;
1961                 }
1962
1963                 // from initial to StartObject
1964                 protected void Read_CommonXamlType (XamlObjectReader r)
1965                 {
1966                         Read_CommonXamlType (r, delegate {
1967                                 Assert.IsNull (r.Instance, "ct#4");
1968                                 });
1969                 }
1970
1971                 protected void Read_CommonXamlType (XamlReader r, Action validateInstance)
1972                 {
1973                         Assert.IsTrue (r.Read (), "ct#1");
1974                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
1975                         Assert.IsNotNull (r.Namespace, "ct#3");
1976                         Assert.AreEqual ("x", r.Namespace.Prefix, "ct#3-2");
1977                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ct#3-3");
1978                         if (validateInstance != null)
1979                                 validateInstance ();
1980
1981                         Assert.IsTrue (r.Read (), "ct#5");
1982                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#6");
1983                 }
1984
1985                 // from initial to StartObject
1986                 protected void Read_CommonClrType (XamlReader r, object obj, params KeyValuePair<string,string> [] additionalNamespaces)
1987                 {
1988                         Assert.IsTrue (r.Read (), "ct#1");
1989                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
1990                         Assert.IsNotNull (r.Namespace, "ct#3");
1991                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ct#3-2");
1992                         Assert.AreEqual ("clr-namespace:" + obj.GetType ().Namespace + ";assembly=" + obj.GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ct#3-3");
1993
1994                         foreach (var kvp in additionalNamespaces) {
1995                                 Assert.IsTrue (r.Read (), "ct#4." + kvp.Key);
1996                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#5." + kvp.Key);
1997                                 Assert.IsNotNull (r.Namespace, "ct#6." + kvp.Key);
1998                                 Assert.AreEqual (kvp.Key, r.Namespace.Prefix, "ct#6-2." + kvp.Key);
1999                                 Assert.AreEqual (kvp.Value, r.Namespace.Namespace, "ct#6-3." + kvp.Key);
2000                         }
2001
2002                         Assert.IsTrue (r.Read (), "ct#7");
2003                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#8");
2004                 }
2005
2006                 protected void ReadBase (XamlReader r)
2007                 {
2008                         Assert.IsTrue (r.Read (), "sbase#1");
2009                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sbase#2");
2010                         Assert.AreEqual (XamlLanguage.Base, r.Member, "sbase#3");
2011
2012                         Assert.IsTrue (r.Read (), "vbase#1");
2013                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vbase#2");
2014                         Assert.IsTrue (r.Value is string, "vbase#3");
2015
2016                         Assert.IsTrue (r.Read (), "ebase#1");
2017                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "ebase#2");
2018                 }
2019         }
2020
2021         public partial class XamlObjectReaderTest
2022         {
2023                 [Test]
2024                 public void Read_Dictionary ()
2025                 {
2026                         var obj = new Dictionary<string,object> ();
2027                         obj ["Foo"] = 5.0;
2028                         obj ["Bar"] = -6.5;
2029                         var r = new XamlObjectReader (obj);
2030                         Read_Dictionary (r);
2031                 }
2032
2033                 [Test]
2034                 public void Read_Dictionary2 ()
2035                 {
2036                         var obj = new Dictionary<string,Type> ();
2037                         obj ["Foo"] = typeof (int);
2038                         obj ["Bar"] = typeof (Dictionary<Type,XamlType>);
2039                         var r = new XamlObjectReader (obj);
2040                         Read_Dictionary2 (r, XamlLanguage.PositionalParameters);
2041                 }
2042
2043                 [Test]
2044                 public void PositionalParameters1 ()
2045                 {
2046                         // Note: this can be read, but cannot be written to XML.
2047                         var obj = new PositionalParametersClass1 ("foo", 5);
2048                         var r = new XamlObjectReader (obj);
2049                         PositionalParameters1 (r);
2050                 }
2051
2052                 [Test]
2053                 public void PositionalParameters2 ()
2054                 {
2055                         var obj = new PositionalParametersWrapper ("foo", 5);
2056                         var r = new XamlObjectReader (obj);
2057                         PositionalParameters2 (r);
2058                 }
2059
2060                 [Test]
2061                 public void ComplexPositionalParameters ()
2062                 {
2063                         var obj = new ComplexPositionalParameterWrapper () { Param = new ComplexPositionalParameterClass (new ComplexPositionalParameterValue () { Foo = "foo" })};
2064                         var r = new XamlObjectReader (obj);
2065                         ComplexPositionalParameters (r);
2066                 }
2067
2068                 [Test]
2069                 public void Read_ListWrapper ()
2070                 {
2071                         var obj = new ListWrapper (new List<int> (new int [] {5, -3, 0}));
2072                         var r = new XamlObjectReader (obj);
2073                         Read_ListWrapper (r);
2074                 }
2075
2076                 [Test]
2077                 public void Read_ListWrapper2 () // read-write list member.
2078                 {
2079                         var obj = new ListWrapper2 (new List<int> (new int [] {5, -3, 0}));
2080                         var r = new XamlObjectReader (obj);
2081                         Read_ListWrapper2 (r);
2082                 }
2083
2084                 [Test]
2085                 public void Read_ContentIncluded ()
2086                 {
2087                         var obj = new ContentIncludedClass () { Content = "foo" };
2088                         var r = new XamlObjectReader (obj);
2089                         Read_ContentIncluded (r);
2090                 }
2091
2092                 [Test]
2093                 public void Read_PropertyDefinition ()
2094                 {
2095                         var obj = new PropertyDefinition () { Modifier = "protected", Name = "foo", Type = XamlLanguage.String };
2096                         var r = new XamlObjectReader (obj);
2097                         Read_PropertyDefinition (r);
2098                 }
2099         }
2100 }