mcs/class/System.Xaml/Test/System.Xaml/XamlReaderTestBase.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         public partial class XamlReaderTestBase
  49         {
  50                 protected void Read_String (XamlReader r)
  51                 {
  52                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
  53                         Assert.IsNull (r.Member, "#2");
  54                         Assert.IsNull (r.Namespace, "#3");
  55                         Assert.IsNull (r.Member, "#4");
  56                         Assert.IsNull (r.Type, "#5");
  57                         Assert.IsNull (r.Value, "#6");
  58
  59                         Assert.IsTrue (r.Read (), "#11");
  60                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
  61                         Assert.IsNotNull (r.Namespace, "#13");
  62                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
  63                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
  64
  65                         Assert.IsTrue (r.Read (), "#21");
  66                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
  67                         Assert.IsNotNull (r.Type, "#23");
  68                         Assert.AreEqual (new XamlType (typeof (string), r.SchemaContext), r.Type, "#23-2");
  69                         Assert.IsNull (r.Namespace, "#25");
  70
  71                         if (r is XamlXmlReader)
  72                                 ReadBase (r);
  73
  74                         Assert.IsTrue (r.Read (), "#31");
  75                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
  76                         Assert.IsNotNull (r.Member, "#33");
  77                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#33-2");
  78                         Assert.IsNull (r.Type, "#34");
  79
  80                         Assert.IsTrue (r.Read (), "#41");
  81                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
  82                         Assert.AreEqual ("foo", r.Value, "#43");
  83                         Assert.IsNull (r.Member, "#44");
  84
  85                         Assert.IsTrue (r.Read (), "#51");
  86                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
  87                         Assert.IsNull (r.Type, "#53");
  88                         Assert.IsNull (r.Member, "#54");
  89
  90                         Assert.IsTrue (r.Read (), "#61");
  91                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
  92                         Assert.IsNull (r.Type, "#63");
  93
  94                         Assert.IsFalse (r.Read (), "#71");
  95                         Assert.IsTrue (r.IsEof, "#72");
  96                 }
  97
  98                 protected void WriteNullMemberAsObject (XamlReader r, Action validateNullInstance)
  99                 {
 100                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 101                         Assert.IsTrue (r.Read (), "#6");
 102                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
 103                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#7-2");
 104                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "#7-3");
 105
 106                         Assert.IsTrue (r.Read (), "#11");
 107                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 108                         Assert.AreEqual ("x", r.Namespace.Prefix, "#12-2");
 109                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#12-3");
 110
 111                         Assert.IsTrue (r.Read (), "#16");
 112                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#17");
 113                         var xt = new XamlType (typeof (TestClass4), r.SchemaContext);
 114                         Assert.AreEqual (xt, r.Type, "#17-2");
 115 //                      Assert.IsTrue (r.Instance is TestClass4, "#17-3");
 116                         Assert.AreEqual (2, xt.GetAllMembers ().Count, "#17-4");
 117
 118                         if (r is XamlXmlReader)
 119                                 ReadBase (r);
 120
 121                         Assert.IsTrue (r.Read (), "#21");
 122                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#22");
 123                         Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#22-2");
 124
 125                         Assert.IsTrue (r.Read (), "#26");
 126                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#27");
 127                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#27-2");
 128                         if (validateNullInstance != null)
 129                                 validateNullInstance ();
 130
 131                         Assert.IsTrue (r.Read (), "#31");
 132                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#32");
 133
 134                         Assert.IsTrue (r.Read (), "#36");
 135                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#37");
 136
 137                         Assert.IsTrue (r.Read (), "#41");
 138                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#42");
 139                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#42-2");
 140
 141                         Assert.IsTrue (r.Read (), "#43");
 142                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#43-2");
 143                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#43-3");
 144                         if (validateNullInstance != null)
 145                                 validateNullInstance ();
 146
 147                         Assert.IsTrue (r.Read (), "#44");
 148                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#44-2");
 149
 150                         Assert.IsTrue (r.Read (), "#46");
 151                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#47");
 152
 153                         Assert.IsTrue (r.Read (), "#51");
 154                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#52");
 155
 156                         Assert.IsFalse (r.Read (), "#56");
 157                         Assert.IsTrue (r.IsEof, "#57");
 158                 }
 159
 160                 protected void StaticMember (XamlReader r)
 161                 {
 162                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 163                         Assert.IsTrue (r.Read (), "#6");
 164                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
 165                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#7-2");
 166                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "#7-3");
 167
 168                         Assert.IsTrue (r.Read (), "#11");
 169                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 170                         Assert.AreEqual ("x", r.Namespace.Prefix, "#12-2");
 171                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#12-3");
 172
 173                         Assert.IsTrue (r.Read (), "#16");
 174                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#17");
 175                         var xt = new XamlType (typeof (TestClass5), r.SchemaContext);
 176                         Assert.AreEqual (xt, r.Type, "#17-2");
 177 //                      Assert.IsTrue (r.Instance is TestClass5, "#17-3");
 178                         Assert.AreEqual (2, xt.GetAllMembers ().Count, "#17-4");
 179                         Assert.IsTrue (xt.GetAllMembers ().Any (xm => xm.Name == "Bar"), "#17-5");
 180                         Assert.IsTrue (xt.GetAllMembers ().Any (xm => xm.Name == "Baz"), "#17-6");
 181
 182                         if (r is XamlXmlReader)
 183                                 ReadBase (r);
 184
 185                         Assert.IsTrue (r.Read (), "#21");
 186                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#22");
 187                         Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#22-2");
 188
 189                         Assert.IsTrue (r.Read (), "#26");
 190                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#27");
 191                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#27-2");
 192 //                      Assert.IsNull (r.Instance, "#27-3");
 193
 194                         Assert.IsTrue (r.Read (), "#31");
 195                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#32");
 196
 197                         Assert.IsTrue (r.Read (), "#36");
 198                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#37");
 199                         // static Foo is not included in GetAllXembers() return value.
 200                         // ReadOnly is not included in GetAllMembers() return value neither.
 201                         // nonpublic Baz is a member, but does not appear in the reader.
 202
 203                         Assert.IsTrue (r.Read (), "#51");
 204                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#52");
 205
 206                         Assert.IsFalse (r.Read (), "#56");
 207                         Assert.IsTrue (r.IsEof, "#57");
 208                 }
 209
 210                 protected void Skip (XamlReader r)
 211                 {
 212                         r.Skip ();
 213                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 214                         r.Skip ();
 215                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2");
 216                         r.Skip ();
 217                         Assert.IsTrue (r.IsEof, "#3");
 218                 }
 219
 220                 protected void Skip2 (XamlReader r)
 221                 {
 222                         r.Read (); // NamespaceDeclaration
 223                         r.Read (); // Type
 224                         if (r is XamlXmlReader)
 225                                 ReadBase (r);
 226                         r.Read (); // Member (Initialization)
 227                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#1");
 228                         r.Skip ();
 229                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#2");
 230                         r.Skip ();
 231                         Assert.IsTrue (r.IsEof, "#3");
 232                 }
 233
 234                 protected void Read_XmlDocument (XamlReader r)
 235                 {
 236                         for (int i = 0; i < 3; i++) {
 237                                 r.Read ();
 238                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-" + i);
 239                         }
 240                         r.Read ();
 241
 242                         Assert.AreEqual (new XamlType (typeof (XmlDocument), r.SchemaContext), r.Type, "#2");
 243                         r.Read ();
 244                         var l = new List<XamlMember> ();
 245                         while (r.NodeType == XamlNodeType.StartMember) {
 246                         // It depends on XmlDocument's implenentation details. It fails on mono only because XmlDocument.SchemaInfo overrides both getter and setter.
 247                         //for (int i = 0; i < 5; i++) {
 248                         //      Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-" + i);
 249                                 l.Add (r.Member);
 250                                 r.Skip ();
 251                         }
 252                         Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "Value"), "#4-1");
 253                         Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "InnerXml"), "#4-2");
 254                         Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "Prefix"), "#4-3");
 255                         Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "PreserveWhitespace"), "#4-4");
 256                         Assert.IsNotNull (l.FirstOrDefault (m => m.Name == "Schemas"), "#4-5");
 257                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#5");
 258                         Assert.IsFalse (r.Read (), "#6");
 259                 }
 260
 261                 protected void Read_NonPrimitive (XamlReader r)
 262                 {
 263                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 264                         Assert.IsTrue (r.Read (), "#6");
 265                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
 266                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#7-2");
 267                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "#7-3");
 268
 269                         Assert.IsTrue (r.Read (), "#11");
 270                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 271                         Assert.AreEqual ("x", r.Namespace.Prefix, "#12-2");
 272                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#12-3");
 273
 274                         Assert.IsTrue (r.Read (), "#16");
 275                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#17");
 276                         var xt = new XamlType (typeof (TestClass3), r.SchemaContext);
 277                         Assert.AreEqual (xt, r.Type, "#17-2");
 278 //                      Assert.IsTrue (r.Instance is TestClass3, "#17-3");
 279
 280                         if (r is XamlXmlReader)
 281                                 ReadBase (r);
 282
 283                         Assert.IsTrue (r.Read (), "#21");
 284                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#22");
 285                         Assert.AreEqual (xt.GetMember ("Nested"), r.Member, "#22-2");
 286
 287                         Assert.IsTrue (r.Read (), "#26");
 288                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#27");
 289                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#27-2");
 290 //                      Assert.IsNull (r.Instance, "#27-3");
 291
 292                         Assert.IsTrue (r.Read (), "#31");
 293                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#32");
 294
 295                         Assert.IsTrue (r.Read (), "#36");
 296                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#37");
 297
 298                         Assert.IsTrue (r.Read (), "#41");
 299                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#42");
 300
 301                         Assert.IsFalse (r.Read (), "#46");
 302                         Assert.IsTrue (r.IsEof, "#47");
 303                 }
 304
 305                 protected void Read_TypeOrTypeExtension (XamlReader r, Action validateInstance, XamlMember ctorArgMember)
 306                 {
 307                         Assert.IsTrue (r.Read (), "#11");
 308                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 309                         Assert.IsNotNull (r.Namespace, "#13");
 310                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 311                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 312 //                      Assert.IsNull (r.Instance, "#14");
 313
 314                         Assert.IsTrue (r.Read (), "#21");
 315                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 316                         Assert.IsNotNull (r.Type, "#23");
 317                         Assert.AreEqual (XamlLanguage.Type, r.Type, "#23-2");
 318                         Assert.IsNull (r.Namespace, "#25");
 319                         if (validateInstance != null)
 320                                 validateInstance ();
 321
 322                         if (r is XamlXmlReader)
 323                                 ReadBase (r);
 324
 325                         Assert.IsTrue (r.Read (), "#31");
 326                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 327                         Assert.IsNotNull (r.Member, "#33");
 328                         Assert.AreEqual (ctorArgMember, r.Member, "#33-2");
 329                         Assert.IsNull (r.Type, "#34");
 330 //                      Assert.IsNull (r.Instance, "#35");
 331
 332                         Assert.IsTrue (r.Read (), "#41");
 333                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 334                         Assert.IsNotNull (r.Value, "#43");
 335                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 336                         Assert.IsNull (r.Member, "#44");
 337 //                      Assert.IsNull (r.Instance, "#45");
 338
 339                         Assert.IsTrue (r.Read (), "#51");
 340                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 341                         Assert.IsNull (r.Type, "#53");
 342                         Assert.IsNull (r.Member, "#54");
 343 //                      Assert.IsNull (r.Instance, "#55");
 344
 345                         Assert.IsTrue (r.Read (), "#61");
 346                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 347                         Assert.IsNull (r.Type, "#63");
 348
 349                         Assert.IsFalse (r.Read (), "#71");
 350                         Assert.IsTrue (r.IsEof, "#72");
 351                 }
 352
 353                 protected void Read_TypeOrTypeExtension2 (XamlReader r, Action validateInstance, XamlMember ctorArgMember)
 354                 {
 355                         Assert.IsTrue (r.Read (), "#11");
 356                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 357
 358                         var defns = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name;
 359
 360                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#13-2");
 361                         Assert.AreEqual (defns, r.Namespace.Namespace, "#13-3:" + r.Namespace.Prefix);
 362
 363                         Assert.IsTrue (r.Read (), "#16");
 364                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#17");
 365                         Assert.IsNotNull (r.Namespace, "#18");
 366                         Assert.AreEqual ("x", r.Namespace.Prefix, "#18-2");
 367                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#18-3:" + r.Namespace.Prefix);
 368
 369                         Assert.IsTrue (r.Read (), "#21");
 370                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 371                         Assert.AreEqual (new XamlType (typeof (TypeExtension), r.SchemaContext), r.Type, "#23-2");
 372                         if (validateInstance != null)
 373                                 validateInstance ();
 374
 375                         if (r is XamlXmlReader)
 376                                 ReadBase (r);
 377
 378                         Assert.IsTrue (r.Read (), "#31");
 379                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 380                         Assert.AreEqual (ctorArgMember, r.Member, "#33-2");
 381
 382                         Assert.IsTrue (r.Read (), "#41");
 383                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 384                         Assert.AreEqual ("TestClass1", r.Value, "#43-2");
 385
 386                         Assert.IsTrue (r.Read (), "#51");
 387                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 388
 389                         Assert.IsTrue (r.Read (), "#61");
 390                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 391
 392                         Assert.IsFalse (r.Read (), "#71");
 393                         Assert.IsTrue (r.IsEof, "#72");
 394                 }
 395
 396                 protected void Read_Reference (XamlReader r)
 397                 {
 398                         Assert.IsTrue (r.Read (), "#11");
 399                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 400                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 401                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 402
 403                         Assert.IsTrue (r.Read (), "#21");
 404                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 405                         var xt = new XamlType (typeof (Reference), r.SchemaContext);
 406                         Assert.AreEqual (xt, r.Type, "#23-2");
 407 //                      Assert.IsTrue (r.Instance is Reference, "#26");
 408                         Assert.IsNotNull (XamlLanguage.Type.SchemaContext, "#23-3");
 409                         Assert.IsNotNull (r.SchemaContext, "#23-4");
 410                         Assert.AreNotEqual (XamlLanguage.Type.SchemaContext, r.SchemaContext, "#23-5");
 411                         Assert.AreNotEqual (XamlLanguage.Reference.SchemaContext, xt.SchemaContext, "#23-6");
 412                         Assert.AreEqual (XamlLanguage.Reference, xt, "#23-7");
 413
 414                         if (r is XamlXmlReader)
 415                                 ReadBase (r);
 416
 417                         Assert.IsTrue (r.Read (), "#31");
 418                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 419                         // unlike TypeExtension there is no PositionalParameters.
 420                         Assert.AreEqual (xt.GetMember ("Name"), r.Member, "#33-2");
 421
 422                         // It is a ContentProperty (besides [ConstructorArgument])
 423                         Assert.IsTrue (r.Read (), "#41");
 424                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 425                         Assert.AreEqual ("FooBar", r.Value, "#43-2");
 426
 427                         Assert.IsTrue (r.Read (), "#51");
 428                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 429
 430                         Assert.IsTrue (r.Read (), "#61");
 431                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 432
 433                         Assert.IsFalse (r.Read (), "#71");
 434                         Assert.IsTrue (r.IsEof, "#72");
 435                 }
 436
 437                 protected void Read_NullOrNullExtension (XamlReader r, Action validateInstance)
 438                 {
 439                         Assert.IsTrue (r.Read (), "#11");
 440                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 441                         Assert.IsNotNull (r.Namespace, "#13");
 442                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 443                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 444 //                      Assert.IsNull (r.Instance, "#14");
 445
 446                         Assert.IsTrue (r.Read (), "#21");
 447                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 448                         Assert.AreEqual (new XamlType (typeof (NullExtension), r.SchemaContext), r.Type, "#23-2");
 449                         if (validateInstance != null)
 450                                 validateInstance ();
 451
 452                         if (r is XamlXmlReader)
 453                                 ReadBase (r);
 454
 455                         Assert.IsTrue (r.Read (), "#61");
 456                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 457
 458                         Assert.IsFalse (r.Read (), "#71");
 459                         Assert.IsTrue (r.IsEof, "#72");
 460                 }
 461
 462                 // almost identical to TypeExtension (only type/instance difference)
 463                 protected void Read_StaticExtension (XamlReader r, XamlMember ctorArgMember)
 464                 {
 465                         Assert.IsTrue (r.Read (), "#11");
 466                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 467                         Assert.IsNotNull (r.Namespace, "#13");
 468                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 469                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 470 //                      Assert.IsNull (r.Instance, "#14");
 471
 472                         Assert.IsTrue (r.Read (), "#21");
 473                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 474                         Assert.AreEqual (new XamlType (typeof (StaticExtension), r.SchemaContext), r.Type, "#23-2");
 475 //                      Assert.IsTrue (r.Instance is StaticExtension, "#26");
 476
 477                         if (r is XamlXmlReader)
 478                                 ReadBase (r);
 479
 480                         Assert.IsTrue (r.Read (), "#31");
 481                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 482                         Assert.AreEqual (ctorArgMember, r.Member, "#33-2");
 483
 484                         Assert.IsTrue (r.Read (), "#41");
 485                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 486                         Assert.AreEqual ("FooBar", r.Value, "#43-2");
 487
 488                         Assert.IsTrue (r.Read (), "#51");
 489                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 490
 491                         Assert.IsTrue (r.Read (), "#61");
 492                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 493
 494                         Assert.IsFalse (r.Read (), "#71");
 495                         Assert.IsTrue (r.IsEof, "#72");
 496                 }
 497
 498                 protected void Read_ListInt32 (XamlReader r, Action validateInstance, List<int> obj)
 499                 {
 500                         Assert.IsTrue (r.Read (), "ns#1-1");
 501                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
 502
 503                         var defns = "clr-namespace:System.Collections.Generic;assembly=mscorlib";
 504
 505                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3");
 506                         Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4");
 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
 514                         Assert.IsTrue (r.Read (), "#21");
 515                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 516                         var xt = new XamlType (typeof (List<int>), r.SchemaContext);
 517                         Assert.AreEqual (xt, r.Type, "#23");
 518                         Assert.IsTrue (xt.IsCollection, "#27");
 519                         if (validateInstance != null)
 520                                 validateInstance ();
 521
 522                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 523
 524                         if (r is XamlXmlReader)
 525                                 ReadBase (r);
 526
 527                         Assert.IsTrue (r.Read (), "#31");
 528                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 529                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
 530
 531                         Assert.IsTrue (r.Read (), "#41");
 532                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 533                         // The value is implementation details, not testable.
 534                         //Assert.AreEqual ("3", r.Value, "#43");
 535
 536                         Assert.IsTrue (r.Read (), "#51");
 537                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 538
 539                         if (obj.Count > 0) { // only when items exist.
 540
 541                         Assert.IsTrue (r.Read (), "#72");
 542                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 543                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 544
 545                         string [] values = {"5", "-3", "2147483647", "0"};
 546                         for (int i = 0; i < 4; i++) {
 547                                 Assert.IsTrue (r.Read (), i + "#73");
 548                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 549                                 Assert.IsTrue (r.Read (), i + "#74");
 550                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 551                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 552                                 Assert.IsTrue (r.Read (), i + "#75");
 553                                 Assert.IsNotNull (r.Value, i + "#75-2");
 554                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 555                                 Assert.IsTrue (r.Read (), i + "#74");
 556                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 557                                 Assert.IsTrue (r.Read (), i + "#75");
 558                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 559                         }
 560
 561                         Assert.IsTrue (r.Read (), "#81");
 562                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 563
 564                         } // end of "if count > 0".
 565
 566                         Assert.IsTrue (r.Read (), "#87");
 567                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88");
 568
 569                         Assert.IsFalse (r.Read (), "#89");
 570                 }
 571
 572                 protected void Read_ListType (XamlReader r, bool isObjectReader)
 573                 {
 574                         Assert.IsTrue (r.Read (), "ns#1-1");
 575                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
 576
 577                         var defns = "clr-namespace:System.Collections.Generic;assembly=mscorlib";
 578                         var defns2 = "clr-namespace:System;assembly=mscorlib";
 579                         var defns3 = "clr-namespace:System.Xaml;assembly=System.Xaml";
 580
 581                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3");
 582                         Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4");
 583
 584                         Assert.IsTrue (r.Read (), "ns#2-1");
 585                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
 586                         Assert.IsNotNull (r.Namespace, "ns#2-3");
 587                         Assert.AreEqual ("s", r.Namespace.Prefix, "ns#2-3-2");
 588                         Assert.AreEqual (defns2, r.Namespace.Namespace, "ns#2-3-3");
 589
 590                         Assert.IsTrue (r.Read (), "ns#3-1");
 591                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#3-2");
 592                         Assert.IsNotNull (r.Namespace, "ns#3-3");
 593                         Assert.AreEqual ("sx", r.Namespace.Prefix, "ns#3-3-2");
 594                         Assert.AreEqual (defns3, r.Namespace.Namespace, "ns#3-3-3");
 595
 596                         Assert.IsTrue (r.Read (), "#11");
 597                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 598                         Assert.IsNotNull (r.Namespace, "#13");
 599                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 600                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 601
 602                         Assert.IsTrue (r.Read (), "#21");
 603                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 604                         var xt = new XamlType (typeof (List<Type>), r.SchemaContext);
 605                         Assert.AreEqual (xt, r.Type, "#23");
 606                         Assert.IsTrue (xt.IsCollection, "#27");
 607
 608                         if (r is XamlXmlReader)
 609                                 ReadBase (r);
 610
 611                         Assert.IsTrue (r.Read (), "#31");
 612                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 613                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
 614
 615                         Assert.IsTrue (r.Read (), "#41");
 616                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 617                         Assert.AreEqual ("2", r.Value, "#43");
 618
 619                         Assert.IsTrue (r.Read (), "#51");
 620                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 621
 622                         Assert.IsTrue (r.Read (), "#72");
 623                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 624                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 625
 626                         string [] values = {"x:Int32", "Dictionary(s:Type, sx:XamlType)"};
 627                         for (int i = 0; i < 2; i++) {
 628                                 Assert.IsTrue (r.Read (), i + "#73");
 629                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 630                                 Assert.IsTrue (r.Read (), i + "#74");
 631                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 632                                 // Here XamlObjectReader and XamlXmlReader significantly differs. (Lucky we can make this test conditional so simply)
 633                                 if (isObjectReader)
 634                                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, i + "#74-3");
 635                                 else
 636                                         Assert.AreEqual (XamlLanguage.Type.GetMember ("Type"), r.Member, i + "#74-3");
 637                                 Assert.IsTrue (r.Read (), i + "#75");
 638                                 Assert.IsNotNull (r.Value, i + "#75-2");
 639                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 640                                 Assert.IsTrue (r.Read (), i + "#74");
 641                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 642                                 Assert.IsTrue (r.Read (), i + "#75");
 643                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 644                         }
 645
 646                         Assert.IsTrue (r.Read (), "#81");
 647                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 648
 649                         Assert.IsTrue (r.Read (), "#87");
 650                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88");
 651
 652                         Assert.IsFalse (r.Read (), "#89");
 653                 }
 654
 655                 protected void Read_ListArray (XamlReader r)
 656                 {
 657                         Assert.IsTrue (r.Read (), "ns#1-1");
 658                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
 659
 660                         var defns = "clr-namespace:System.Collections.Generic;assembly=mscorlib";
 661                         var defns2 = "clr-namespace:System;assembly=mscorlib";
 662                         var defns3 = "clr-namespace:System.Xaml;assembly=System.Xaml";
 663
 664                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3");
 665                         Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4");
 666
 667                         Assert.IsTrue (r.Read (), "ns#2-1");
 668                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
 669                         Assert.IsNotNull (r.Namespace, "ns#2-3");
 670                         Assert.AreEqual ("s", r.Namespace.Prefix, "ns#2-3-2");
 671                         Assert.AreEqual (defns2, r.Namespace.Namespace, "ns#2-3-3");
 672
 673                         Assert.IsTrue (r.Read (), "#11");
 674                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 675                         Assert.IsNotNull (r.Namespace, "#13");
 676                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 677                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 678
 679                         Assert.IsTrue (r.Read (), "#21");
 680                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 681                         var xt = new XamlType (typeof (List<Array>), r.SchemaContext);
 682                         Assert.AreEqual (xt, r.Type, "#23");
 683                         Assert.IsTrue (xt.IsCollection, "#27");
 684
 685                         if (r is XamlXmlReader)
 686                                 ReadBase (r);
 687
 688                         Assert.IsTrue (r.Read (), "#31");
 689                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 690                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
 691
 692                         Assert.IsTrue (r.Read (), "#41");
 693                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 694                         Assert.AreEqual ("2", r.Value, "#43");
 695
 696                         Assert.IsTrue (r.Read (), "#51");
 697                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 698
 699                         Assert.IsTrue (r.Read (), "#72");
 700                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 701                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 702
 703                         string [] values = {"x:Int32", "x:String"};
 704                         for (int i = 0; i < 2; i++) {
 705                                 Assert.IsTrue (r.Read (), i + "#73");
 706                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 707                                 Assert.AreEqual (XamlLanguage.Array, r.Type, i + "#73-3");
 708                                 Assert.IsTrue (r.Read (), i + "#74");
 709                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 710                                 Assert.AreEqual (XamlLanguage.Array.GetMember ("Type"), r.Member, i + "#74-3");
 711                                 Assert.IsTrue (r.Read (), i + "#75");
 712                                 Assert.IsNotNull (r.Value, i + "#75-2");
 713                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 714                                 Assert.IsTrue (r.Read (), i + "#74");
 715                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 716
 717                                 Assert.IsTrue (r.Read (), i + "#75");
 718                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#75-2");
 719                                 Assert.AreEqual (XamlLanguage.Array.GetMember ("Items"), r.Member, i + "#75-3");
 720                                 Assert.IsTrue (r.Read (), i + "#75-4");
 721                                 Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, i + "#75-5");
 722                                 Assert.IsTrue (r.Read (), i + "#75-7");
 723                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#75-8");
 724                                 Assert.AreEqual (XamlLanguage.Items, r.Member, i + "#75-9");
 725
 726                                 for (int j = 0; j < 3; j++) {
 727                                         Assert.IsTrue (r.Read (), i + "#76-" + j);
 728                                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#76-2"+ "-" + j);
 729                                         Assert.IsTrue (r.Read (), i + "#76-3"+ "-" + j);
 730                                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#76-4"+ "-" + j);
 731                                         Assert.IsTrue (r.Read (), i + "#76-5"+ "-" + j);
 732                                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, i + "#76-6"+ "-" + j);
 733                                         Assert.IsTrue (r.Read (), i + "#76-7"+ "-" + j);
 734                                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#76-8"+ "-" + j);
 735                                         Assert.IsTrue (r.Read (), i + "#76-9"+ "-" + j);
 736                                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#76-10"+ "-" + j);
 737                                 }
 738
 739                                 Assert.IsTrue (r.Read (), i + "#77");
 740                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#77-2");
 741
 742                                 Assert.IsTrue (r.Read (), i + "#78");
 743                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#78-2");
 744
 745                                 Assert.IsTrue (r.Read (), i + "#79");
 746                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#79-2");
 747
 748                                 Assert.IsTrue (r.Read (), i + "#80");
 749                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#80-2");
 750                         }
 751
 752                         Assert.IsTrue (r.Read (), "#81");
 753                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 754
 755                         Assert.IsTrue (r.Read (), "#87");
 756                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88");
 757
 758                         Assert.IsFalse (r.Read (), "#89");
 759                 }
 760
 761                 protected void Read_ArrayList (XamlReader r)
 762                 {
 763                         Assert.IsTrue (r.Read (), "ns#1-1");
 764                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
 765
 766                         var defns = "clr-namespace:System.Collections;assembly=mscorlib";
 767
 768                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3");
 769                         Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4");
 770
 771                         Assert.IsTrue (r.Read (), "#11");
 772                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 773                         Assert.IsNotNull (r.Namespace, "#13");
 774                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 775                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 776
 777                         Assert.IsTrue (r.Read (), "#21");
 778                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 779                         var xt = new XamlType (typeof (ArrayList), r.SchemaContext);
 780                         Assert.AreEqual (xt, r.Type, "#23");
 781 //                      Assert.AreEqual (obj, r.Instance, "#26");
 782                         Assert.IsTrue (xt.IsCollection, "#27");
 783
 784                         if (r is XamlXmlReader)
 785                                 ReadBase (r);
 786
 787                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 788
 789                         Assert.IsTrue (r.Read (), "#31");
 790                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 791                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
 792
 793                         Assert.IsTrue (r.Read (), "#41");
 794                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 795                         // The value is implementation details, not testable.
 796                         //Assert.AreEqual ("3", r.Value, "#43");
 797
 798                         Assert.IsTrue (r.Read (), "#51");
 799                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 800
 801                         Assert.IsTrue (r.Read (), "#72");
 802                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 803                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 804
 805                         string [] values = {"5", "-3", "0"};
 806                         for (int i = 0; i < 3; i++) {
 807                                 Assert.IsTrue (r.Read (), i + "#73");
 808                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 809                                 Assert.IsTrue (r.Read (), i + "#74");
 810                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 811                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 812                                 Assert.IsTrue (r.Read (), i + "#75");
 813                                 Assert.IsNotNull (r.Value, i + "#75-2");
 814                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 815                                 Assert.IsTrue (r.Read (), i + "#74");
 816                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 817                                 Assert.IsTrue (r.Read (), i + "#75");
 818                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 819                         }
 820
 821                         Assert.IsTrue (r.Read (), "#81");
 822                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 823
 824                         Assert.IsTrue (r.Read (), "#87");
 825                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88");
 826
 827                         Assert.IsFalse (r.Read (), "#89");
 828                 }
 829
 830                 protected void Read_ArrayOrArrayExtensionOrMyArrayExtension (XamlReader r, Action validateInstance, Type extType)
 831                 {
 832                         if (extType == typeof (MyArrayExtension)) {
 833                                 Assert.IsTrue (r.Read (), "#1");
 834                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
 835                                 Assert.IsNotNull (r.Namespace, "#3");
 836                                 Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
 837                         }
 838                         Assert.IsTrue (r.Read (), "#11");
 839                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 840                         Assert.IsNotNull (r.Namespace, "#13");
 841                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 842                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 843
 844                         Assert.IsTrue (r.Read (), "#21");
 845                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 846                         var xt = new XamlType (extType, r.SchemaContext);
 847                         Assert.AreEqual (xt, r.Type, "#23");
 848                         if (validateInstance != null)
 849                                 validateInstance ();
 850
 851                         if (r is XamlXmlReader)
 852                                 ReadBase (r);
 853
 854                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 855
 856                         Assert.IsTrue (r.Read (), "#31");
 857                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 858                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33");
 859
 860                         Assert.IsTrue (r.Read (), "#41");
 861                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 862                         Assert.AreEqual ("x:Int32", r.Value, "#43");
 863
 864                         Assert.IsTrue (r.Read (), "#51");
 865                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 866
 867                         Assert.IsTrue (r.Read (), "#61");
 868                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
 869                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
 870
 871                         Assert.IsTrue (r.Read (), "#71");
 872                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
 873                         Assert.IsNull (r.Type, "#71-3");
 874                         Assert.IsNull (r.Member, "#71-4");
 875                         Assert.IsNull (r.Value, "#71-5");
 876
 877                         Assert.IsTrue (r.Read (), "#72");
 878                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 879                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 880
 881                         string [] values = {"5", "-3", "0"};
 882                         for (int i = 0; i < 3; i++) {
 883                                 Assert.IsTrue (r.Read (), i + "#73");
 884                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 885                                 Assert.IsTrue (r.Read (), i + "#74");
 886                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 887                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 888                                 Assert.IsTrue (r.Read (), i + "#75");
 889                                 Assert.IsNotNull (r.Value, i + "#75-2");
 890                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 891                                 Assert.IsTrue (r.Read (), i + "#74");
 892                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 893                                 Assert.IsTrue (r.Read (), i + "#75");
 894                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 895                         }
 896
 897                         Assert.IsTrue (r.Read (), "#81");
 898                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 899
 900                         Assert.IsTrue (r.Read (), "#83");
 901                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
 902
 903                         Assert.IsTrue (r.Read (), "#85");
 904                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ArrayExtension.Items
 905
 906                         Assert.IsTrue (r.Read (), "#87");
 907                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ArrayExtension
 908
 909                         Assert.IsFalse (r.Read (), "#89");
 910                 }
 911
 912                 // It gives Type member, not PositionalParameters... and no Items member here.
 913                 protected void Read_ArrayExtension2 (XamlReader r)
 914                 {
 915                         Assert.IsTrue (r.Read (), "#11");
 916                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 917                         Assert.IsNotNull (r.Namespace, "#13");
 918                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 919                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 920 //                      Assert.IsNull (r.Instance, "#14");
 921
 922                         Assert.IsTrue (r.Read (), "#21");
 923                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 924                         var xt = new XamlType (typeof (ArrayExtension), r.SchemaContext);
 925                         Assert.AreEqual (xt, r.Type, "#23-2");
 926 //                      Assert.IsTrue (r.Instance is ArrayExtension, "#26");
 927
 928                         if (r is XamlXmlReader)
 929                                 ReadBase (r);
 930
 931                         Assert.IsTrue (r.Read (), "#31");
 932                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 933                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33-2");
 934
 935                         Assert.IsTrue (r.Read (), "#41");
 936                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 937                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 938
 939                         Assert.IsTrue (r.Read (), "#51");
 940                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 941
 942                         Assert.IsTrue (r.Read (), "#61");
 943                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 944
 945                         Assert.IsFalse (r.Read (), "#71");
 946                         Assert.IsTrue (r.IsEof, "#72");
 947                 }
 948
 949                 protected void Read_CustomMarkupExtension (XamlReader r)
 950                 {
 951                         r.Read (); // ns
 952                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 953                         r.Read (); // ns
 954                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-2");
 955                         r.Read ();
 956                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
 957                         Assert.IsFalse (r.IsEof, "#1");
 958                         var xt = r.Type;
 959
 960                         if (r is XamlXmlReader)
 961                                 ReadBase (r);
 962
 963                         r.Read ();
 964                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#2-1");
 965                         Assert.IsFalse (r.IsEof, "#2-2");
 966                         Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#2-3");
 967
 968                         Assert.IsTrue (r.Read (), "#2-4");
 969                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#2-5");
 970                         Assert.AreEqual ("v2", r.Value, "#2-6");
 971
 972                         Assert.IsTrue (r.Read (), "#2-7");
 973                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#2-8");
 974
 975                         r.Read ();
 976                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-1");
 977                         Assert.IsFalse (r.IsEof, "#3-2");
 978                         Assert.AreEqual (xt.GetMember ("Baz"), r.Member, "#3-3");
 979
 980                         Assert.IsTrue (r.Read (), "#3-4");
 981                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#3-5");
 982                         Assert.AreEqual ("v7", r.Value, "#3-6");
 983
 984                         Assert.IsTrue (r.Read (), "#3-7");
 985                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#3-8");
 986
 987                         r.Read ();
 988                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#4-1");
 989                         Assert.IsFalse (r.IsEof, "#4-2");
 990                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4-3");
 991                         Assert.IsTrue (r.Read (), "#4-4");
 992                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#4-5");
 993                         Assert.AreEqual ("x:Int32", r.Value, "#4-6");
 994
 995                         Assert.IsTrue (r.Read (), "#4-7");
 996                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#4-8");
 997
 998                         Assert.IsTrue (r.Read (), "#5");
 999                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#5-2");
1000
1001                         Assert.IsFalse (r.Read (), "#6");
1002                 }
1003
1004                 protected void Read_CustomMarkupExtension2 (XamlReader r)
1005                 {
1006                         r.Read (); // ns
1007                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1008                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1009                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1010                         var xt = r.Type;
1011                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension2)), xt, "#2");
1012
1013                         if (r is XamlXmlReader)
1014                                 ReadBase (r);
1015
1016                         Assert.IsTrue (r.Read (), "#3");
1017                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1018                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1019                         Assert.IsTrue (r.Read (), "#5");
1020                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension2", r.Value, "#6");
1021                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1022                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1023                         Assert.IsFalse (r.Read (), "#9");
1024                 }
1025
1026                 protected void Read_CustomMarkupExtension3 (XamlReader r)
1027                 {
1028                         r.Read (); // ns
1029                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1030                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1031                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1032                         var xt = r.Type;
1033                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension3)), xt, "#2");
1034
1035                         if (r is XamlXmlReader)
1036                                 ReadBase (r);
1037
1038                         Assert.IsTrue (r.Read (), "#3");
1039                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1040                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1041                         Assert.IsTrue (r.Read (), "#5");
1042                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension3", r.Value, "#6");
1043                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1044                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1045                         Assert.IsFalse (r.Read (), "#9");
1046                 }
1047
1048                 protected void Read_CustomMarkupExtension4 (XamlReader r)
1049                 {
1050                         r.Read (); // ns
1051                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1052                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1053                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1054                         var xt = r.Type;
1055                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension4)), xt, "#2");
1056
1057                         if (r is XamlXmlReader)
1058                                 ReadBase (r);
1059
1060                         Assert.IsTrue (r.Read (), "#3");
1061                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1062                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1063                         Assert.IsTrue (r.Read (), "#5");
1064                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension4", r.Value, "#6");
1065                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1066                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1067                         Assert.IsFalse (r.Read (), "#9");
1068                 }
1069
1070                 protected void Read_CustomMarkupExtension5 (XamlReader r)
1071                 {
1072                         r.Read (); // ns
1073                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1074                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1075                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1076                         var xt = r.Type;
1077                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension5)), xt, "#2");
1078
1079                         if (r is XamlXmlReader)
1080                                 ReadBase (r);
1081
1082                         Assert.IsTrue (r.Read (), "#3");
1083                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1084                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#4");
1085                         Assert.IsTrue (r.Read (), "#5");
1086                         Assert.AreEqual ("foo", r.Value, "#6");
1087                         Assert.IsTrue (r.Read (), "#7");
1088                         Assert.AreEqual ("bar", r.Value, "#8");
1089                         Assert.IsTrue (r.Read (), "#9");
1090                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#10");
1091                         Assert.IsTrue (r.Read (), "#11");
1092                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#12");
1093                         Assert.IsFalse (r.Read (), "#13");
1094                 }
1095
1096                 protected void Read_CustomMarkupExtension6 (XamlReader r)
1097                 {
1098                         r.Read (); // ns
1099                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1100                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1101                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1102                         var xt = r.Type;
1103                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension6)), xt, "#2");
1104
1105                         if (r is XamlXmlReader)
1106                                 ReadBase (r);
1107
1108                         Assert.IsTrue (r.Read (), "#3");
1109                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1110                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4"); // this is the difference between MyExtension5 and MyExtension6: it outputs constructor arguments as normal members
1111                         Assert.IsTrue (r.Read (), "#5");
1112                         Assert.AreEqual ("foo", r.Value, "#6");
1113                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1114                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1115                         Assert.IsFalse (r.Read (), "#9");
1116                 }
1117
1118                 protected void Read_ArgumentAttributed (XamlReader r, object obj)
1119                 {
1120                         Read_CommonClrType (r, obj, new KeyValuePair<string,string> ("x", XamlLanguage.Xaml2006Namespace));
1121
1122                         if (r is XamlXmlReader)
1123                                 ReadBase (r);
1124
1125                         var args = Read_AttributedArguments_String (r, new string [] {"arg1", "arg2"});
1126                         Assert.AreEqual ("foo", args [0], "#1");
1127                         Assert.AreEqual ("bar", args [1], "#2");
1128                 }
1129
1130                 protected void Read_Dictionary (XamlReader r)
1131                 {
1132                         Assert.IsTrue (r.Read (), "ns#1-1");
1133                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1134                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1135                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1136                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "ns#1-5");
1137
1138                         Assert.IsTrue (r.Read (), "ns#2-1");
1139                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1140                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1141                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1142                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1143
1144                         Assert.IsTrue (r.Read (), "so#1-1");
1145                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1146                         var xt = new XamlType (typeof (Dictionary<string,object>), r.SchemaContext);
1147                         Assert.AreEqual (xt, r.Type, "so#1-3");
1148 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1149
1150                         if (r is XamlXmlReader)
1151                                 ReadBase (r);
1152
1153                         Assert.IsTrue (r.Read (), "smitems#1");
1154                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smitems#2");
1155                         Assert.AreEqual (XamlLanguage.Items, r.Member, "smitems#3");
1156
1157                         for (int i = 0; i < 2; i++) {
1158
1159                                 // start of an item
1160                                 Assert.IsTrue (r.Read (), "soi#1-1." + i);
1161                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "soi#1-2." + i);
1162                                 var xt2 = new XamlType (typeof (double), r.SchemaContext);
1163                                 Assert.AreEqual (xt2, r.Type, "soi#1-3." + i);
1164
1165                                 Assert.IsTrue (r.Read (), "smi#1-1." + i);
1166                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#1-2." + i);
1167                                 Assert.AreEqual (XamlLanguage.Key, r.Member, "smi#1-3." + i);
1168
1169                                 Assert.IsTrue (r.Read (), "svi#1-1." + i);
1170                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#1-2." + i);
1171                                 Assert.AreEqual (i == 0 ? "Foo" : "Bar", r.Value, "svi#1-3." + i);
1172
1173                                 Assert.IsTrue (r.Read (), "emi#1-1." + i);
1174                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#1-2." + i);
1175
1176                                 Assert.IsTrue (r.Read (), "smi#2-1." + i);
1177                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#2-2." + i);
1178                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, "smi#2-3." + i);
1179
1180                                 Assert.IsTrue (r.Read (), "svi#2-1." + i);
1181                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#2-2." + i);
1182                                 Assert.AreEqual (i == 0 ? "5" : "-6.5", r.Value, "svi#2-3." + i); // converted to string(!)
1183
1184                                 Assert.IsTrue (r.Read (), "emi#2-1." + i);
1185                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#2-2." + i);
1186
1187                                 Assert.IsTrue (r.Read (), "eoi#1-1." + i);
1188                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eoi#1-2." + i);
1189                                 // end of an item
1190                         }
1191
1192                         Assert.IsTrue (r.Read (), "emitems#1");
1193                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emitems#2"); // XamlLanguage.Items
1194
1195                         Assert.IsTrue (r.Read (), "eo#1-1");
1196                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2"); // Dictionary
1197
1198                         Assert.IsFalse (r.Read (), "end");
1199                 }
1200
1201                 protected void Read_Dictionary2 (XamlReader r, XamlMember ctorArgMember)
1202                 {
1203                         Assert.IsTrue (r.Read (), "ns#1-1");
1204                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1205                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1206                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1207                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "ns#1-5");
1208
1209                         Assert.IsTrue (r.Read (), "ns#2-1");
1210                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1211                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1212                         Assert.AreEqual ("s", r.Namespace.Prefix, "ns#2-4");
1213                         Assert.AreEqual ("clr-namespace:System;assembly=mscorlib", r.Namespace.Namespace, "ns#2-5");
1214
1215                         Assert.IsTrue (r.Read (), "ns#3-1");
1216                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#3-2");
1217                         Assert.IsNotNull (r.Namespace, "ns#3-3");
1218                         Assert.AreEqual ("sx", r.Namespace.Prefix, "ns#3-4");
1219                         Assert.AreEqual ("clr-namespace:System.Xaml;assembly=System.Xaml", r.Namespace.Namespace, "ns#3-5");
1220
1221                         Assert.IsTrue (r.Read (), "ns#4-1");
1222                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#4-2");
1223                         Assert.IsNotNull (r.Namespace, "ns#4-3");
1224                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#4-4");
1225                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#4-5");
1226
1227                         Assert.IsTrue (r.Read (), "so#1-1");
1228                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1229                         var xt = new XamlType (typeof (Dictionary<string,Type>), r.SchemaContext);
1230                         Assert.AreEqual (xt, r.Type, "so#1-3");
1231 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1232
1233                         if (r is XamlXmlReader)
1234                                 ReadBase (r);
1235
1236                         Assert.IsTrue (r.Read (), "smitems#1");
1237                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smitems#2");
1238                         Assert.AreEqual (XamlLanguage.Items, r.Member, "smitems#3");
1239
1240                         for (int i = 0; i < 2; i++) {
1241
1242                                 // start of an item
1243                                 Assert.IsTrue (r.Read (), "soi#1-1." + i);
1244                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "soi#1-2." + i);
1245                                 var xt2 = XamlLanguage.Type;
1246                                 Assert.AreEqual (xt2, r.Type, "soi#1-3." + i);
1247
1248                                 if (r is XamlObjectReader) {
1249                                         Read_Dictionary2_ConstructorArgument (r, ctorArgMember, i);
1250                                         Read_Dictionary2_Key (r, i);
1251                                 } else {
1252                                         Read_Dictionary2_Key (r, i);
1253                                         Read_Dictionary2_ConstructorArgument (r, ctorArgMember, i);
1254                                 }
1255
1256                                 Assert.IsTrue (r.Read (), "eoi#1-1." + i);
1257                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eoi#1-2." + i);
1258                                 // end of an item
1259                         }
1260
1261                         Assert.IsTrue (r.Read (), "emitems#1");
1262                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emitems#2"); // XamlLanguage.Items
1263
1264                         Assert.IsTrue (r.Read (), "eo#1-1");
1265                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2"); // Dictionary
1266
1267                         Assert.IsFalse (r.Read (), "end");
1268                 }
1269
1270                 void Read_Dictionary2_ConstructorArgument (XamlReader r, XamlMember ctorArgMember, int i)
1271                 {
1272                         Assert.IsTrue (r.Read (), "smi#1-1." + i);
1273                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#1-2." + i);
1274                         Assert.AreEqual (ctorArgMember, r.Member, "smi#1-3." + i);
1275
1276                         Assert.IsTrue (r.Read (), "svi#1-1." + i);
1277                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#1-2." + i);
1278                         Assert.AreEqual (i == 0 ? "x:Int32" : "Dictionary(s:Type, sx:XamlType)", r.Value, "svi#1-3." + i);
1279
1280                         Assert.IsTrue (r.Read (), "emi#1-1." + i);
1281                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#1-2." + i);
1282                 }
1283
1284                 void Read_Dictionary2_Key (XamlReader r, int i)
1285                 {
1286                         Assert.IsTrue (r.Read (), "smi#2-1." + i);
1287                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#2-2." + i);
1288                         Assert.AreEqual (XamlLanguage.Key, r.Member, "smi#2-3." + i);
1289
1290                         Assert.IsTrue (r.Read (), "svi#2-1." + i);
1291                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#2-2." + i);
1292                         Assert.AreEqual (i == 0 ? "Foo" : "Bar", r.Value, "svi#2-3." + i);
1293
1294                         Assert.IsTrue (r.Read (), "emi#2-1." + i);
1295                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#2-2." + i);
1296                 }
1297
1298                 protected void PositionalParameters1 (XamlReader r)
1299                 {
1300                         // ns1 > T:PositionalParametersClass1 > M:_PositionalParameters > foo > 5 > EM:_PositionalParameters > ET:PositionalParametersClass1
1301
1302                         Assert.IsTrue (r.Read (), "ns#1-1");
1303                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1304                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1305                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1306                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1307
1308                         Assert.IsTrue (r.Read (), "so#1-1");
1309                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1310                         var xt = new XamlType (typeof (PositionalParametersClass1), r.SchemaContext);
1311                         Assert.AreEqual (xt, r.Type, "so#1-3");
1312 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1313
1314                         if (r is XamlXmlReader)
1315                                 ReadBase (r);
1316
1317                         Assert.IsTrue (r.Read (), "sposprm#1");
1318                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1319                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "sposprm#3");
1320
1321                         Assert.IsTrue (r.Read (), "sva#1-1");
1322                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1323                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1324
1325                         Assert.IsTrue (r.Read (), "sva#2-1");
1326                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#2-2");
1327                         Assert.AreEqual ("5", r.Value, "sva#2-3");
1328
1329                         Assert.IsTrue (r.Read (), "eposprm#1");
1330                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2"); // XamlLanguage.PositionalParameters
1331
1332                         Assert.IsTrue (r.Read (), "eo#1-1");
1333                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1334
1335                         Assert.IsFalse (r.Read (), "end");
1336                 }
1337
1338                 protected void PositionalParameters2 (XamlReader r)
1339                 {
1340                         // ns1 > T:PositionalParametersWrapper > M:Body > T:PositionalParametersClass1 > M:_PositionalParameters > foo > 5 > EM:_PositionalParameters > ET:PositionalParametersClass1
1341
1342                         Assert.IsTrue (r.Read (), "ns#1-1");
1343                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1344                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1345                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1346                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1347
1348                         Assert.IsTrue (r.Read (), "so#1-1");
1349                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1350                         var xt = new XamlType (typeof (PositionalParametersWrapper), r.SchemaContext);
1351                         Assert.AreEqual (xt, r.Type, "so#1-3");
1352 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1353
1354                         if (r is XamlXmlReader)
1355                                 ReadBase (r);
1356
1357                         Assert.IsTrue (r.Read (), "sm#1-1");
1358                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#1-2");
1359                         Assert.AreEqual (xt.GetMember ("Body"), r.Member, "sm#1-3");
1360
1361                         xt = new XamlType (typeof (PositionalParametersClass1), r.SchemaContext);
1362                         Assert.IsTrue (r.Read (), "so#2-1");
1363                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1364                         Assert.AreEqual (xt, r.Type, "so#2-3");
1365 //                      Assert.AreEqual (obj.Body, r.Instance, "so#2-4");
1366
1367                         Assert.IsTrue (r.Read (), "sposprm#1");
1368                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1369                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "sposprm#3");
1370
1371                         Assert.IsTrue (r.Read (), "sva#1-1");
1372                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1373                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1374
1375                         Assert.IsTrue (r.Read (), "sva#2-1");
1376                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#2-2");
1377                         Assert.AreEqual ("5", r.Value, "sva#2-3");
1378
1379                         Assert.IsTrue (r.Read (), "eposprm#1");
1380                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2"); // XamlLanguage.PositionalParameters
1381
1382                         Assert.IsTrue (r.Read (), "eo#2-1");
1383                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1384
1385                         Assert.IsTrue (r.Read (), "em#1-1");
1386                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eo#1-2");
1387
1388                         Assert.IsTrue (r.Read (), "eo#1-1");
1389                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1390
1391                         Assert.IsFalse (r.Read (), "end");
1392                 }
1393
1394                 protected void ComplexPositionalParameters (XamlReader r)
1395                 {
1396                         Assert.IsTrue (r.Read (), "ns#1-1");
1397                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1398                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1399                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1400                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1401
1402                         Assert.IsTrue (r.Read (), "ns#2-1");
1403                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1404                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1405                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1406                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1407
1408                         Assert.IsTrue (r.Read (), "so#1-1");
1409                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1410                         var xt = new XamlType (typeof (ComplexPositionalParameterWrapper), r.SchemaContext);
1411                         Assert.AreEqual (xt, r.Type, "so#1-3");
1412 //                      Assert.AreEqual (obj, r.Instance, "so#1-4");
1413
1414                         if (r is XamlXmlReader)
1415                                 ReadBase (r);
1416
1417                         Assert.IsTrue (r.Read (), "sm#1-1");
1418                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#1-2");
1419                         Assert.AreEqual (xt.GetMember ("Param"), r.Member, "sm#1-3");
1420
1421                         xt = r.SchemaContext.GetXamlType (typeof (ComplexPositionalParameterClass));
1422                         Assert.IsTrue (r.Read (), "so#2-1");
1423                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1424                         Assert.AreEqual (xt, r.Type, "so#2-3");
1425 //                      Assert.AreEqual (obj.Param, r.Instance, "so#2-4");
1426
1427                         Assert.IsTrue (r.Read (), "sarg#1");
1428                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sarg#2");
1429                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "sarg#3");
1430
1431                         Assert.IsTrue (r.Read (), "so#3-1");
1432                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#3-2");
1433                         xt = r.SchemaContext.GetXamlType (typeof (ComplexPositionalParameterValue));
1434                         Assert.AreEqual (xt, r.Type, "so#3-3");
1435
1436                         Assert.IsTrue (r.Read (), "sm#3-1");
1437                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#3-2");
1438                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "sm#3-3");
1439                         Assert.IsTrue (r.Read (), "v#3-1");
1440                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "v#3-2");
1441                         Assert.AreEqual ("foo", r.Value, "v#3-3");
1442
1443                         Assert.IsTrue (r.Read (), "em#3-1");
1444                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em#3-2");
1445                         Assert.IsTrue (r.Read (), "eo#3-1");
1446                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#3-2");
1447
1448                         Assert.IsTrue (r.Read (), "earg#1");
1449                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "earg#2"); // XamlLanguage.Arguments
1450
1451                         Assert.IsTrue (r.Read (), "eo#2-1");
1452                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1453
1454                         Assert.IsTrue (r.Read (), "em#1-1");
1455                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eo#1-2");
1456
1457                         Assert.IsTrue (r.Read (), "eo#1-1");
1458                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1459
1460                         Assert.IsFalse (r.Read (), "end");
1461                 }
1462
1463                 protected void Read_ListWrapper (XamlReader r)
1464                 {
1465                         Assert.IsTrue (r.Read (), "#1");
1466                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
1467                         Assert.IsNotNull (r.Namespace, "#3");
1468                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
1469
1470                         Assert.IsTrue (r.Read (), "#11");
1471                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
1472                         Assert.IsNotNull (r.Namespace, "#13");
1473                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
1474                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
1475
1476                         Assert.IsTrue (r.Read (), "#21");
1477                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
1478                         var xt = new XamlType (typeof (ListWrapper), r.SchemaContext);
1479                         Assert.AreEqual (xt, r.Type, "#23");
1480 //                      Assert.AreEqual (obj, r.Instance, "#26");
1481
1482                         if (r is XamlXmlReader)
1483                                 ReadBase (r);
1484
1485                         Assert.IsTrue (r.Read (), "#61");
1486                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
1487                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
1488
1489                         Assert.IsTrue (r.Read (), "#71");
1490                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
1491                         Assert.IsNull (r.Type, "#71-3");
1492                         Assert.IsNull (r.Member, "#71-4");
1493                         Assert.IsNull (r.Value, "#71-5");
1494
1495                         Assert.IsTrue (r.Read (), "#72");
1496                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
1497                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
1498
1499                         string [] values = {"5", "-3", "0"};
1500                         for (int i = 0; i < 3; i++) {
1501                                 Assert.IsTrue (r.Read (), i + "#73");
1502                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
1503                                 Assert.IsTrue (r.Read (), i + "#74");
1504                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
1505                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
1506                                 Assert.IsTrue (r.Read (), i + "#75");
1507                                 Assert.IsNotNull (r.Value, i + "#75-2");
1508                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
1509                                 Assert.IsTrue (r.Read (), i + "#74");
1510                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
1511                                 Assert.IsTrue (r.Read (), i + "#75");
1512                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
1513                         }
1514
1515                         Assert.IsTrue (r.Read (), "#81");
1516                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
1517
1518                         Assert.IsTrue (r.Read (), "#83");
1519                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
1520
1521                         Assert.IsTrue (r.Read (), "#85");
1522                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ListWrapper.Items
1523
1524                         Assert.IsTrue (r.Read (), "#87");
1525                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ListWrapper
1526
1527                         Assert.IsFalse (r.Read (), "#89");
1528                 }
1529
1530                 protected void Read_ListWrapper2 (XamlReader r)
1531                 {
1532                         Assert.IsTrue (r.Read (), "#1");
1533                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
1534                         Assert.IsNotNull (r.Namespace, "#3");
1535                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
1536
1537                         Assert.IsTrue (r.Read (), "#6");
1538                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
1539                         Assert.IsNotNull (r.Namespace, "#8");
1540                         Assert.AreEqual ("scg", r.Namespace.Prefix, "#8-2");
1541                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "#8-3");
1542
1543                         Assert.IsTrue (r.Read (), "#11");
1544                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
1545                         Assert.IsNotNull (r.Namespace, "#13");
1546                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
1547                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
1548
1549                         Assert.IsTrue (r.Read (), "#21");
1550                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
1551                         var xt = new XamlType (typeof (ListWrapper2), r.SchemaContext);
1552                         Assert.AreEqual (xt, r.Type, "#23");
1553 //                      Assert.AreEqual (obj, r.Instance, "#26");
1554
1555                         if (r is XamlXmlReader)
1556                                 ReadBase (r);
1557
1558                         Assert.IsTrue (r.Read (), "#61");
1559                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
1560                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
1561
1562                         Assert.IsTrue (r.Read (), "#71");
1563                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#71-2");
1564                         xt = r.SchemaContext.GetXamlType (typeof (List<int>));
1565                         Assert.AreEqual (xt, r.Type, "#71-3");
1566                         Assert.IsNull (r.Member, "#71-4");
1567                         Assert.IsNull (r.Value, "#71-5");
1568
1569                         // Capacity
1570                         Assert.IsTrue (r.Read (), "#31");
1571                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
1572                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
1573
1574                         Assert.IsTrue (r.Read (), "#41");
1575                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
1576                         // The value is implementation details, not testable.
1577                         //Assert.AreEqual ("3", r.Value, "#43");
1578
1579                         Assert.IsTrue (r.Read (), "#51");
1580                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
1581
1582                         // Items
1583                         Assert.IsTrue (r.Read (), "#72");
1584                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
1585                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
1586
1587                         string [] values = {"5", "-3", "0"};
1588                         for (int i = 0; i < 3; i++) {
1589                                 Assert.IsTrue (r.Read (), i + "#73");
1590                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
1591                                 Assert.IsTrue (r.Read (), i + "#74");
1592                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
1593                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
1594                                 Assert.IsTrue (r.Read (), i + "#75");
1595                                 Assert.IsNotNull (r.Value, i + "#75-2");
1596                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
1597                                 Assert.IsTrue (r.Read (), i + "#74");
1598                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
1599                                 Assert.IsTrue (r.Read (), i + "#75");
1600                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
1601                         }
1602
1603                         Assert.IsTrue (r.Read (), "#81");
1604                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
1605
1606                         Assert.IsTrue (r.Read (), "#83");
1607                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // StartObject(of List<int>)
1608
1609                         Assert.IsTrue (r.Read (), "#85");
1610                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ListWrapper.Items
1611
1612                         Assert.IsTrue (r.Read (), "#87");
1613                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ListWrapper
1614
1615                         Assert.IsFalse (r.Read (), "#89");
1616                 }
1617
1618                 protected void Read_ContentIncluded (XamlReader r)
1619                 {
1620                         Assert.IsTrue (r.Read (), "ns#1-1");
1621                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1622                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1623                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1624                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1625
1626                         Assert.IsTrue (r.Read (), "so#1-1");
1627                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1628                         var xt = new XamlType (typeof (ContentIncludedClass), r.SchemaContext);
1629                         Assert.AreEqual (xt, r.Type, "so#1-3");
1630
1631                         if (r is XamlXmlReader)
1632                                 ReadBase (r);
1633
1634                         Assert.IsTrue (r.Read (), "sposprm#1");
1635                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1636                         Assert.AreEqual (xt.GetMember ("Content"), r.Member, "sposprm#3");
1637
1638                         Assert.IsTrue (r.Read (), "sva#1-1");
1639                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1640                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1641
1642                         Assert.IsTrue (r.Read (), "eposprm#1");
1643                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2");
1644
1645                         Assert.IsTrue (r.Read (), "eo#1-1");
1646                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1647
1648                         Assert.IsFalse (r.Read (), "end");
1649                 }
1650
1651                 protected void Read_PropertyDefinition (XamlReader r)
1652                 {
1653                         Assert.IsTrue (r.Read (), "ns#1-1");
1654                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1655                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1656                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#1-4");
1657                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#1-5");
1658
1659                         Assert.IsTrue (r.Read (), "so#1-1");
1660                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1661                         var xt = new XamlType (typeof (PropertyDefinition), r.SchemaContext);
1662                         Assert.AreEqual (xt, r.Type, "so#1-3");
1663
1664                         if (r is XamlXmlReader)
1665                                 ReadBase (r);
1666
1667                         Assert.IsTrue (r.Read (), "smod#1");
1668                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smod#2");
1669                         Assert.AreEqual (xt.GetMember ("Modifier"), r.Member, "smod#3");
1670
1671                         Assert.IsTrue (r.Read (), "vmod#1");
1672                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vmod#2");
1673                         Assert.AreEqual ("protected", r.Value, "vmod#3");
1674
1675                         Assert.IsTrue (r.Read (), "emod#1");
1676                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emod#2");
1677
1678                         Assert.IsTrue (r.Read (), "sname#1");
1679                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sname#2");
1680                         Assert.AreEqual (xt.GetMember ("Name"), r.Member, "sname#3");
1681
1682                         Assert.IsTrue (r.Read (), "vname#1");
1683                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vname#2");
1684                         Assert.AreEqual ("foo", r.Value, "vname#3");
1685
1686                         Assert.IsTrue (r.Read (), "ename#1");
1687                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "ename#2");
1688
1689                         Assert.IsTrue (r.Read (), "stype#1");
1690                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "stype#2");
1691                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "stype#3");
1692
1693                         Assert.IsTrue (r.Read (), "vtype#1");
1694                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vtype#2");
1695                         Assert.AreEqual ("x:String", r.Value, "vtype#3");
1696
1697                         Assert.IsTrue (r.Read (), "etype#1");
1698                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "etype#2");
1699
1700                         Assert.IsTrue (r.Read (), "eo#1-1");
1701                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1702
1703                         Assert.IsFalse (r.Read (), "end");
1704                 }
1705
1706                 protected void Read_StaticExtensionWrapper (XamlReader r)
1707                 {
1708                         Assert.IsTrue (r.Read (), "ns#1-1");
1709                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1710                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1711                         Assert.AreEqual ("", r.Namespace.Prefix, "ns#1-4");
1712                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1713
1714                         Assert.IsTrue (r.Read (), "ns#2-1");
1715                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1716                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1717                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1718                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1719
1720                         Assert.IsTrue (r.Read (), "so#1-1");
1721                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1722                         var xt = new XamlType (typeof (StaticExtensionWrapper), r.SchemaContext);
1723                         Assert.AreEqual (xt, r.Type, "so#1-3");
1724
1725                         if (r is XamlXmlReader)
1726                                 ReadBase (r);
1727
1728                         Assert.IsTrue (r.Read (), "sprm#1");
1729                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sprm#2");
1730                         Assert.AreEqual (xt.GetMember ("Param"), r.Member, "sprm#3");
1731
1732                         Assert.IsTrue (r.Read (), "so#2-1");
1733                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1734                         xt = new XamlType (typeof (StaticExtension), r.SchemaContext);
1735                         Assert.AreEqual (xt, r.Type, "so#2-3");
1736
1737                         Assert.IsTrue (r.Read (), "smbr#1");
1738                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smbr#2");
1739                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "smbr#3");
1740
1741                         Assert.IsTrue (r.Read (), "vmbr#1");
1742                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vmbr#2");
1743                         Assert.AreEqual ("StaticExtensionWrapper.Foo", r.Value, "vmbr#3");
1744
1745                         Assert.IsTrue (r.Read (), "embr#1");
1746                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "embr#2");
1747
1748                         Assert.IsTrue (r.Read (), "eo#2-1");
1749                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1750
1751                         Assert.IsTrue (r.Read (), "emod#1-1");
1752                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emod#1-2");
1753
1754                         Assert.IsTrue (r.Read (), "eo#1-1");
1755                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1756
1757                         Assert.IsFalse (r.Read (), "end");
1758                 }
1759
1760                 protected void Read_TypeExtensionWrapper (XamlReader r)
1761                 {
1762                         Assert.IsTrue (r.Read (), "ns#1-1");
1763                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1764                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1765                         Assert.AreEqual ("", r.Namespace.Prefix, "ns#1-4");
1766                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1767
1768                         Assert.IsTrue (r.Read (), "ns#2-1");
1769                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1770                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1771                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1772                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1773
1774                         Assert.IsTrue (r.Read (), "so#1-1");
1775                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1776                         var xt = new XamlType (typeof (TypeExtensionWrapper), r.SchemaContext);
1777                         Assert.AreEqual (xt, r.Type, "so#1-3");
1778
1779                         if (r is XamlXmlReader)
1780                                 ReadBase (r);
1781
1782                         Assert.IsTrue (r.Read (), "sprm#1");
1783                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sprm#2");
1784                         Assert.AreEqual (xt.GetMember ("Param"), r.Member, "sprm#3");
1785
1786                         Assert.IsTrue (r.Read (), "so#2-1");
1787                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1788                         xt = new XamlType (typeof (TypeExtension), r.SchemaContext);
1789                         Assert.AreEqual (xt, r.Type, "so#2-3");
1790
1791                         Assert.IsTrue (r.Read (), "smbr#1");
1792                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smbr#2");
1793                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "smbr#3");
1794
1795                         Assert.IsTrue (r.Read (), "vmbr#1");
1796                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vmbr#2");
1797                         Assert.AreEqual (String.Empty, r.Value, "vmbr#3");
1798
1799                         Assert.IsTrue (r.Read (), "embr#1");
1800                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "embr#2");
1801
1802                         Assert.IsTrue (r.Read (), "eo#2-1");
1803                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1804
1805                         Assert.IsTrue (r.Read (), "emod#1-1");
1806                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emod#1-2");
1807
1808                         Assert.IsTrue (r.Read (), "eo#1-1");
1809                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1810
1811                         Assert.IsFalse (r.Read (), "end");
1812                 }
1813
1814                 protected void Read_EventContainer (XamlReader r)
1815                 {
1816                         Assert.IsTrue (r.Read (), "ns#1-1");
1817                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1818                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1819                         Assert.AreEqual ("", r.Namespace.Prefix, "ns#1-4");
1820                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1821
1822                         Assert.IsTrue (r.Read (), "so#1-1");
1823                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1824                         var xt = new XamlType (typeof (EventContainer), r.SchemaContext);
1825                         Assert.AreEqual (xt, r.Type, "so#1-3");
1826
1827                         if (r is XamlXmlReader)
1828                                 ReadBase (r);
1829
1830                         Assert.IsTrue (r.Read (), "eo#1-1");
1831                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1832
1833                         Assert.IsFalse (r.Read (), "end");
1834                 }
1835
1836                 protected void Read_NamedItems (XamlReader r, bool isObjectReader)
1837                 {
1838                         Assert.IsTrue (r.Read (), "ns#1-1");
1839                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1840                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1841                         Assert.AreEqual ("", r.Namespace.Prefix, "ns#1-4");
1842                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1843
1844                         Assert.IsTrue (r.Read (), "ns#2-1");
1845                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1846                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1847                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1848                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1849
1850                         var xt = new XamlType (typeof (NamedItem), r.SchemaContext);
1851
1852                         // foo
1853                         Assert.IsTrue (r.Read (), "so#1-1");
1854                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1855                         Assert.AreEqual (xt, r.Type, "so#1-3");
1856
1857                         if (r is XamlXmlReader)
1858                                 ReadBase (r);
1859
1860                         Assert.IsTrue (r.Read (), "sxname#1");
1861                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sxname#2");
1862                         Assert.AreEqual (XamlLanguage.Name, r.Member, "sxname#3");
1863
1864                         Assert.IsTrue (r.Read (), "vxname#1");
1865                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vxname#2");
1866                         Assert.AreEqual ("__ReferenceID0", r.Value, "vxname#3");
1867
1868                         Assert.IsTrue (r.Read (), "exname#1");
1869                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "exname#2");
1870
1871                         Assert.IsTrue (r.Read (), "sname#1");
1872                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sname#2");
1873                         Assert.AreEqual (xt.GetMember ("ItemName"), r.Member, "sname#3");
1874
1875                         Assert.IsTrue (r.Read (), "vname#1");
1876                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vname#2");
1877                         Assert.AreEqual ("foo", r.Value, "vname#3");
1878
1879                         Assert.IsTrue (r.Read (), "ename#1");
1880                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "ename#2");
1881
1882                         Assert.IsTrue (r.Read (), "sItems#1");
1883                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sItems#2");
1884                         Assert.AreEqual (xt.GetMember ("References"), r.Member, "sItems#3");
1885
1886                         Assert.IsTrue (r.Read (), "goc#1-1");
1887                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "goc#1-2");
1888
1889                         Assert.IsTrue (r.Read (), "smbr#1");
1890                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smbr#2");
1891                         Assert.AreEqual (XamlLanguage.Items, r.Member, "smbr#3");
1892
1893                         // bar
1894                         Assert.IsTrue (r.Read (), "soc#1-1");
1895                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "soc#1-2");
1896                         Assert.AreEqual (xt, r.Type, "soc#1-3");
1897
1898                         Assert.IsTrue (r.Read (), "smbrc#1");
1899                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smbrc#2");
1900                         Assert.AreEqual (xt.GetMember ("ItemName"), r.Member, "smbrc#3");
1901
1902                         Assert.IsTrue (r.Read (), "vmbrc#1");
1903                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vmbrc#2");
1904                         Assert.AreEqual ("bar", r.Value, "vmbrc#3");
1905
1906                         Assert.IsTrue (r.Read (), "embrc#1");
1907                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "embrc#2");
1908
1909                         Assert.IsTrue (r.Read (), "sItemsc#1");
1910                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sItemsc#2");
1911                         Assert.AreEqual (xt.GetMember ("References"), r.Member, "sItemsc#3");
1912
1913                         Assert.IsTrue (r.Read (), "god#2-1");
1914                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "god#2-2");
1915
1916                         Assert.IsTrue (r.Read (), "smbrd#1");
1917                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smbrd#2");
1918                         Assert.AreEqual (XamlLanguage.Items, r.Member, "smbrd#3");
1919
1920                         Assert.IsTrue (r.Read (), "sod#1-1");
1921                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "sod#1-2");
1922                         Assert.AreEqual (XamlLanguage.Reference, r.Type, "sod#1-3");
1923
1924                         Assert.IsTrue (r.Read (), "smbrd#1");
1925                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smbrd#2");
1926                         if (isObjectReader)
1927                                 Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "smbrd#3");
1928                         else
1929                                 Assert.AreEqual (XamlLanguage.Reference.GetMember ("Name"), r.Member, "smbrd#3");
1930
1931                         Assert.IsTrue (r.Read (), "vmbrd#1");
1932                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vmbrd#2");
1933                         Assert.AreEqual ("__ReferenceID0", r.Value, "vmbrd#3");
1934
1935                         Assert.IsTrue (r.Read (), "embrd#1");
1936                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "embrd#2");
1937
1938                         Assert.IsTrue (r.Read (), "eod#2-1");
1939                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eod#2-2");
1940
1941                         Assert.IsTrue (r.Read (), "eItemsc#1");
1942                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eItemsc#2");
1943
1944                         Assert.IsTrue (r.Read (), "eoc#2-1");
1945                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eoc#2-2");
1946
1947                         Assert.IsTrue (r.Read (), "emod#1-1");
1948                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emod#1-2");
1949
1950                         Assert.IsTrue (r.Read (), "eo#1-1");
1951                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1952
1953                         // baz
1954                         Assert.IsTrue (r.Read (), "so3#1-1");
1955                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so3#1-2");
1956                         Assert.AreEqual (xt, r.Type, "so3#1-3");
1957                         Assert.IsTrue (r.Read (), "sname3#1");
1958                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sname3#2");
1959                         Assert.AreEqual (xt.GetMember ("ItemName"), r.Member, "sname3#3");
1960
1961                         Assert.IsTrue (r.Read (), "vname3#1");
1962                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vname3#2");
1963                         Assert.AreEqual ("baz", r.Value, "vname3#3");
1964
1965                         Assert.IsTrue (r.Read (), "ename3#1");
1966                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "ename3#2");
1967
1968                         Assert.IsTrue (r.Read (), "eo3#1-1");
1969                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo3#1-2");
1970
1971                         Assert.IsTrue (r.Read (), "em2#1-1");
1972                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em2#1-2");
1973
1974                         Assert.IsTrue (r.Read (), "eo2#1-1");
1975                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo2#1-2");
1976
1977                         Assert.IsTrue (r.Read (), "em#1-1");
1978                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em#1-2");
1979
1980                         Assert.IsTrue (r.Read (), "eo#1-1");
1981                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1982
1983                         Assert.IsFalse (r.Read (), "end");
1984                 }
1985
1986                 protected void Read_NamedItems2 (XamlReader r, bool isObjectReader)
1987                 {
1988                         Assert.IsTrue (r.Read (), "ns#1-1");
1989                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1990                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1991                         Assert.AreEqual ("", r.Namespace.Prefix, "ns#1-4");
1992                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1993
1994                         Assert.IsTrue (r.Read (), "ns#2-1");
1995                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1996                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1997                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1998                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1999
2000                         var xt = new XamlType (typeof (NamedItem2), r.SchemaContext);
2001
2002                         // i1
2003                         Assert.IsTrue (r.Read (), "so1#1");
2004                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so1#2");
2005                         Assert.AreEqual (xt, r.Type, "so1#3");
2006
2007                         if (r is XamlXmlReader)
2008                                 ReadBase (r);
2009
2010                         Assert.IsTrue (r.Read (), "sm1#1");
2011                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm1#2");
2012                         Assert.AreEqual (xt.GetMember ("ItemName"), r.Member, "sm1#3");
2013
2014                         Assert.IsTrue (r.Read (), "v1#1");
2015                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "v1#2");
2016                         Assert.AreEqual ("i1", r.Value, "v1#3");
2017
2018                         Assert.IsTrue (r.Read (), "em1#1");
2019                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em1#2");
2020
2021                         Assert.IsTrue (r.Read (), "srefs1#1");
2022                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "srefs1#2");
2023                         Assert.AreEqual (xt.GetMember ("References"), r.Member, "srefs1#3");
2024
2025                         Assert.IsTrue (r.Read (), "go1#1");
2026                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "go1#2");
2027
2028                         Assert.IsTrue (r.Read (), "sitems1#1");
2029                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sitems1#2");
2030                         Assert.AreEqual (XamlLanguage.Items, r.Member, "sitems1#3");
2031
2032                         // i2
2033                         Assert.IsTrue (r.Read (), "so2#1-1");
2034                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so2#1-2");
2035                         Assert.AreEqual (xt, r.Type, "so2#1-3");
2036                         Assert.IsTrue (r.Read (), "sm2#1");
2037                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm2#2");
2038                         Assert.AreEqual (xt.GetMember ("ItemName"), r.Member, "sm2#3");
2039
2040                         Assert.IsTrue (r.Read (), "v2#1");
2041                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "v2#2");
2042                         Assert.AreEqual ("i2", r.Value, "v2#3");
2043
2044                         Assert.IsTrue (r.Read (), "em2#1");
2045                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em2#2");
2046
2047                         Assert.IsTrue (r.Read (), "srefs2#1");
2048                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "srefs2#2");
2049                         Assert.AreEqual (xt.GetMember ("References"), r.Member, "srefs2#3");
2050
2051                         Assert.IsTrue (r.Read (), "go2#1");
2052                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "go2#2");
2053
2054                         Assert.IsTrue (r.Read (), "sItems1#1");
2055                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sItems1#2");
2056                         Assert.AreEqual (XamlLanguage.Items, r.Member, "sItems1#3");
2057
2058                         Assert.IsTrue (r.Read (), "so3#1");
2059                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so3#2");
2060                         Assert.AreEqual (xt, r.Type, "so3#3");
2061                         Assert.IsTrue (r.Read (), "sm3#1");
2062                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm3#2");
2063                         Assert.AreEqual (xt.GetMember ("ItemName"), r.Member, "sm3#3");
2064
2065                         Assert.IsTrue (r.Read (), "v3#1");
2066                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "v3#2");
2067                         Assert.AreEqual ("i3", r.Value, "v3#3");
2068
2069                         Assert.IsTrue (r.Read (), "em3#1");
2070                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em3#2");
2071
2072                         Assert.IsTrue (r.Read (), "eo3#1");
2073                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo3#2");
2074
2075                         Assert.IsTrue (r.Read (), "eitems2#1");
2076                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eitems2#2");
2077
2078                         Assert.IsTrue (r.Read (), "ego2#1");
2079                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "ego2#2");
2080
2081                         Assert.IsTrue (r.Read (), "erefs2#1");
2082                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "erefs2#2");
2083
2084                         Assert.IsTrue (r.Read (), "eo2#1");
2085                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo2#2");
2086
2087                         // i4
2088                         Assert.IsTrue (r.Read (), "so4#1");
2089                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so4#2");
2090                         Assert.AreEqual (xt, r.Type, "so4#3");
2091
2092                         Assert.IsTrue (r.Read (), "sm4#1");
2093                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm4#2");
2094                         Assert.AreEqual (xt.GetMember ("ItemName"), r.Member, "sm4#3");
2095
2096                         Assert.IsTrue (r.Read (), "v4#1");
2097                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "v4#2");
2098                         Assert.AreEqual ("i4", r.Value, "v4#3");
2099
2100                         Assert.IsTrue (r.Read (), "em4#1");
2101                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em4#2");
2102
2103                         Assert.IsTrue (r.Read (), "srefs4#1");
2104                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "srefs4#2");
2105                         Assert.AreEqual (xt.GetMember ("References"), r.Member, "srefs4#3");
2106
2107                         Assert.IsTrue (r.Read (), "go4#1");
2108                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "go4#2");
2109
2110                         Assert.IsTrue (r.Read (), "sitems4#1");
2111                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sitems4#2");
2112                         Assert.AreEqual (XamlLanguage.Items, r.Member, "sitems4#3");
2113
2114                         Assert.IsTrue (r.Read (), "sor1#1");
2115                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "sor1#2");
2116                         Assert.AreEqual (XamlLanguage.Reference, r.Type, "sor1#3");
2117
2118                         Assert.IsTrue (r.Read (), "smr1#1");
2119                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smr1#2");
2120                         if (isObjectReader)
2121                                 Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "smr1#3");
2122                         else
2123                                 Assert.AreEqual (XamlLanguage.Reference.GetMember ("Name"), r.Member, "smr1#3");
2124
2125                         Assert.IsTrue (r.Read (), "vr1#1");
2126                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vr1#2");
2127                         Assert.AreEqual ("i3", r.Value, "vr1#3");
2128
2129                         Assert.IsTrue (r.Read (), "emr1#1");
2130                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emr1#2");
2131
2132                         Assert.IsTrue (r.Read (), "eor#1");
2133                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eor#2");
2134
2135                         Assert.IsTrue (r.Read (), "eitems4#1");
2136                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eitems4#2");
2137
2138                         Assert.IsTrue (r.Read (), "ego4#1");
2139                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "ego4#2");
2140
2141                         Assert.IsTrue (r.Read (), "erefs4#1");
2142                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "erefs4#2");
2143
2144                         Assert.IsTrue (r.Read (), "eo4#1-1");
2145                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo4#1-2");
2146
2147                         Assert.IsTrue (r.Read (), "eitems1#1");
2148                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eitems1#2");
2149
2150                         Assert.IsTrue (r.Read (), "ego1#1");
2151                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "ego1#2");
2152
2153                         Assert.IsTrue (r.Read (), "erefs1#1");
2154                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "erefs1#2");
2155
2156                         Assert.IsTrue (r.Read (), "eo1#1");
2157                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo1#2");
2158
2159                         Assert.IsFalse (r.Read (), "end");
2160                 }
2161
2162                 protected void Read_XmlSerializableWrapper (XamlReader r, bool isObjectReader)
2163                 {
2164                         Assert.IsTrue (r.Read (), "ns#1-1");
2165                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
2166                         Assert.IsNotNull (r.Namespace, "ns#1-3");
2167                         Assert.AreEqual ("", r.Namespace.Prefix, "ns#1-4");
2168                         var assns = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name;
2169                         Assert.AreEqual (assns, r.Namespace.Namespace, "ns#1-5");
2170
2171                         Assert.IsTrue (r.Read (), "ns#2-1");
2172                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
2173                         Assert.IsNotNull (r.Namespace, "ns#2-3");
2174                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
2175                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
2176
2177                         // t:XmlSerializableWrapper
2178                         Assert.IsTrue (r.Read (), "so#1-1");
2179                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
2180                         var xt = new XamlType (typeof (XmlSerializableWrapper), r.SchemaContext);
2181                         Assert.AreEqual (xt, r.Type, "so#1-3");
2182
2183                         if (r is XamlXmlReader)
2184                                 ReadBase (r);
2185
2186                         // m:Value
2187                         Assert.IsTrue (r.Read (), "sm1#1");
2188                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm1#2");
2189                         Assert.AreEqual (xt.GetMember ("Value"), r.Member, "sm1#3");
2190
2191                         // x:XData
2192                         Assert.IsTrue (r.Read (), "so#2-1");
2193                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
2194                         Assert.AreEqual (XamlLanguage.XData, r.Type, "so#2-3");
2195                         if (r is XamlObjectReader)
2196                                 Assert.IsNull (((XamlObjectReader) r).Instance, "xdata-instance");
2197
2198                         Assert.IsTrue (r.Read (), "sm2#1");
2199                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm2#2");
2200                         Assert.AreEqual (XamlLanguage.XData.GetMember ("Text"), r.Member, "sm2#3");
2201
2202                         Assert.IsTrue (r.Read (), "v1#1");
2203                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "v1#2");
2204                         var val = isObjectReader ? "<root />" : "<root xmlns=\"" + assns + "\" />";
2205                         Assert.AreEqual (val, r.Value, "v1#3");
2206
2207                         Assert.IsTrue (r.Read (), "em2#1");
2208                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em2#2");
2209
2210                         Assert.IsTrue (r.Read (), "eo#2-1");
2211                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
2212
2213                         Assert.IsTrue (r.Read (), "em1#1");
2214                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em1#2");
2215
2216                         // /t:XmlSerializableWrapper
2217                         Assert.IsTrue (r.Read (), "eo#1-1");
2218                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
2219
2220                         Assert.IsFalse (r.Read (), "end");
2221                 }
2222
2223                 protected void Read_XmlSerializable (XamlReader r)
2224                 {
2225                         Assert.IsTrue (r.Read (), "ns#1-1");
2226                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
2227                         Assert.IsNotNull (r.Namespace, "ns#1-3");
2228                         Assert.AreEqual ("", r.Namespace.Prefix, "ns#1-4");
2229                         var assns = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name;
2230                         Assert.AreEqual (assns, r.Namespace.Namespace, "ns#1-5");
2231
2232                         // t:XmlSerializable
2233                         Assert.IsTrue (r.Read (), "so#1-1");
2234                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
2235                         var xt = new XamlType (typeof (XmlSerializable), r.SchemaContext);
2236                         Assert.AreEqual (xt, r.Type, "so#1-3");
2237
2238                         if (r is XamlXmlReader)
2239                                 ReadBase (r);
2240
2241                         // /t:XmlSerializable
2242                         Assert.IsTrue (r.Read (), "eo#1-1");
2243                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
2244
2245                         Assert.IsFalse (r.Read (), "end");
2246                 }
2247
2248                 protected void Read_ListXmlSerializable (XamlReader r)
2249                 {
2250                         while (true) {
2251                                 r.Read ();
2252                                 if (r.Member == XamlLanguage.Items)
2253                                         break;
2254                                 if (r.IsEof)
2255                                         Assert.Fail ("Items did not appear");
2256                         }
2257
2258                         // t:XmlSerializable (yes...it is not XData!)
2259                         Assert.IsTrue (r.Read (), "so#1-1");
2260                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
2261                         var xt = new XamlType (typeof (XmlSerializable), r.SchemaContext);
2262                         Assert.AreEqual (xt, r.Type, "so#1-3");
2263
2264                         // /t:XmlSerializable
2265                         Assert.IsTrue (r.Read (), "eo#1-1");
2266                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
2267
2268                         r.Close ();
2269                 }
2270
2271                 protected void Read_AttachedProperty (XamlReader r)
2272                 {
2273                         var at = new XamlType (typeof (Attachable), r.SchemaContext);
2274
2275                         Assert.IsTrue (r.Read (), "ns#1-1");
2276                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
2277                         Assert.IsNotNull (r.Namespace, "ns#1-3");
2278                         Assert.AreEqual ("", r.Namespace.Prefix, "ns#1-4");
2279                         var assns = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name;
2280                         Assert.AreEqual (assns, r.Namespace.Namespace, "ns#1-5");
2281
2282                         // t:AttachedWrapper
2283                         Assert.IsTrue (r.Read (), "so#1-1");
2284                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
2285                         var xt = new XamlType (typeof (AttachedWrapper), r.SchemaContext);
2286                         Assert.AreEqual (xt, r.Type, "so#1-3");
2287
2288                         if (r is XamlXmlReader)
2289                                 ReadBase (r);
2290
2291                         ReadAttachedProperty (r, at.GetAttachableMember ("Foo"), "x", "x");
2292
2293                         // m:Value
2294                         Assert.IsTrue (r.Read (), "sm#2-1");
2295                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#sm#2-2");
2296                         Assert.AreEqual (xt.GetMember ("Value"), r.Member, "sm#2-3");
2297
2298                         // t:Attached
2299                         Assert.IsTrue (r.Read (), "so#2-1");
2300                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#so#2-2");
2301                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (Attached)), r.Type, "so#2-3");
2302
2303                         ReadAttachedProperty (r, at.GetAttachableMember ("Foo"), "y", "y");
2304
2305                         Assert.IsTrue (r.Read (), "eo#2-1");
2306                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#eo#2-2");
2307
2308                         // /m:Value
2309                         Assert.IsTrue (r.Read (), "em#2-1");
2310                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#em#2-2");
2311
2312                         // /t:AttachedWrapper
2313                         Assert.IsTrue (r.Read (), "eo#1-1");
2314                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
2315
2316                         Assert.IsFalse (r.Read (), "end");
2317                 }
2318
2319                 void ReadAttachedProperty (XamlReader r, XamlMember xm, string value, string label)
2320                 {
2321                         Assert.IsTrue (r.Read (), label + "#1-1");
2322                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, label + "#1-2");
2323                         Assert.AreEqual (xm, r.Member, label + "#1-3");
2324
2325                         Assert.IsTrue (r.Read (), label + "#2-1");
2326                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, label + "#2-2");
2327                         Assert.AreEqual (value, r.Value, label + "2-3");
2328
2329                         Assert.IsTrue (r.Read (), label + "#3-1");
2330                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, label + "#3-2");
2331                 }
2332
2333                 protected void Read_CommonXamlPrimitive (object obj)
2334                 {
2335                         var r = new XamlObjectReader (obj);
2336                         Read_CommonXamlType (r);
2337                         Read_Initialization (r, obj);
2338                 }
2339
2340                 // from StartMember of Initialization to EndMember
2341                 protected string Read_Initialization (XamlReader r, object comparableValue)
2342                 {
2343                         Assert.IsTrue (r.Read (), "init#1");
2344                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "init#2");
2345                         Assert.IsNotNull (r.Member, "init#3");
2346                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "init#3-2");
2347                         Assert.IsTrue (r.Read (), "init#4");
2348                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "init#5");
2349                         Assert.AreEqual (typeof (string), r.Value.GetType (), "init#6");
2350                         string ret = (string) r.Value;
2351                         if (comparableValue != null)
2352                                 Assert.AreEqual (comparableValue.ToString (), r.Value, "init#6-2");
2353                         Assert.IsTrue (r.Read (), "init#7");
2354                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "init#8");
2355                         return ret;
2356                 }
2357
2358                 protected object [] Read_AttributedArguments_String (XamlReader r, string [] argNames) // valid only for string arguments.
2359                 {
2360                         object [] ret = new object [argNames.Length];
2361
2362                         Assert.IsTrue (r.Read (), "attarg.Arguments.Start1");
2363                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.Arguments.Start2");
2364                         Assert.IsNotNull (r.Member, "attarg.Arguments.Start3");
2365                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "attarg.Arguments.Start4");
2366                         for (int i = 0; i < argNames.Length; i++) {
2367                                 string arg = argNames [i];
2368                                 Assert.IsTrue (r.Read (), "attarg.ArgStartObject1." + arg);
2369                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "attarg.ArgStartObject2." + arg);
2370                                 Assert.AreEqual (typeof (string), r.Type.UnderlyingType, "attarg.ArgStartObject3." + arg);
2371                                 Assert.IsTrue (r.Read (), "attarg.ArgStartMember1." + arg);
2372                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.ArgStartMember2." + arg);
2373                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, "attarg.ArgStartMember3." + arg); // (as the argument is string here by definition)
2374                                 Assert.IsTrue (r.Read (), "attarg.ArgValue1." + arg);
2375                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "attarg.ArgValue2." + arg);
2376                                 Assert.AreEqual (typeof (string), r.Value.GetType (), "attarg.ArgValue3." + arg);
2377                                 ret [i] = r.Value;
2378                                 Assert.IsTrue (r.Read (), "attarg.ArgEndMember1." + arg);
2379                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.ArgEndMember2." + arg);
2380                                 Assert.IsTrue (r.Read (), "attarg.ArgEndObject1." + arg);
2381                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "attarg.ArgEndObject2." + arg);
2382                         }
2383                         Assert.IsTrue (r.Read (), "attarg.Arguments.End1");
2384                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.Arguments.End2");
2385                         return ret;
2386                 }
2387
2388                 // from initial to StartObject
2389                 protected void Read_CommonXamlType (XamlObjectReader r)
2390                 {
2391                         Read_CommonXamlType (r, delegate {
2392                                 Assert.IsNull (r.Instance, "ct#4");
2393                                 });
2394                 }
2395
2396                 protected void Read_CommonXamlType (XamlReader r, Action validateInstance)
2397                 {
2398                         Assert.IsTrue (r.Read (), "ct#1");
2399                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
2400                         Assert.IsNotNull (r.Namespace, "ct#3");
2401                         Assert.AreEqual ("x", r.Namespace.Prefix, "ct#3-2");
2402                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ct#3-3");
2403                         if (validateInstance != null)
2404                                 validateInstance ();
2405
2406                         Assert.IsTrue (r.Read (), "ct#5");
2407                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#6");
2408                 }
2409
2410                 // from initial to StartObject
2411                 protected void Read_CommonClrType (XamlReader r, object obj, params KeyValuePair<string,string> [] additionalNamespaces)
2412                 {
2413                         Assert.IsTrue (r.Read (), "ct#1");
2414                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
2415                         Assert.IsNotNull (r.Namespace, "ct#3");
2416                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ct#3-2");
2417                         Assert.AreEqual ("clr-namespace:" + obj.GetType ().Namespace + ";assembly=" + obj.GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ct#3-3");
2418
2419                         foreach (var kvp in additionalNamespaces) {
2420                                 Assert.IsTrue (r.Read (), "ct#4." + kvp.Key);
2421                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#5." + kvp.Key);
2422                                 Assert.IsNotNull (r.Namespace, "ct#6." + kvp.Key);
2423                                 Assert.AreEqual (kvp.Key, r.Namespace.Prefix, "ct#6-2." + kvp.Key);
2424                                 Assert.AreEqual (kvp.Value, r.Namespace.Namespace, "ct#6-3." + kvp.Key);
2425                         }
2426
2427                         Assert.IsTrue (r.Read (), "ct#7");
2428                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#8");
2429                 }
2430
2431                 protected void ReadBase (XamlReader r)
2432                 {
2433                         Assert.IsTrue (r.Read (), "sbase#1");
2434                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sbase#2");
2435                         Assert.AreEqual (XamlLanguage.Base, r.Member, "sbase#3");
2436
2437                         Assert.IsTrue (r.Read (), "vbase#1");
2438                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vbase#2");
2439                         Assert.IsTrue (r.Value is string, "vbase#3");
2440
2441                         Assert.IsTrue (r.Read (), "ebase#1");
2442                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "ebase#2");
2443                 }
2444         }
2445 }