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

   1 //
   2 // Copyright (C) 2010 Novell Inc. http://novell.com
   3 //
   4 // Permission is hereby granted, free of charge, to any person obtaining
   5 // a copy of this software and associated documentation files (the
   6 // "Software"), to deal in the Software without restriction, including
   7 // without limitation the rights to use, copy, modify, merge, publish,
   8 // distribute, sublicense, and/or sell copies of the Software, and to
   9 // permit persons to whom the Software is furnished to do so, subject to
  10 // the following conditions:
  11 //
  12 // The above copyright notice and this permission notice shall be
  13 // included in all copies or substantial portions of the Software.
  14 //
  15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  19 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  20 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  21 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22 //
  23 using System;
  24 using System.Collections;
  25 using System.Collections.Generic;
  26 using System.ComponentModel;
  27 using System.IO;
  28 using System.Linq;
  29 using System.Reflection;
  30 using System.Windows.Markup;
  31 using System.Xaml;
  32 using System.Xaml.Schema;
  33 using System.Xml;
  34 using NUnit.Framework;
  35
  36 using CategoryAttribute = NUnit.Framework.CategoryAttribute;
  37
  38 // Some test result remarks:
  39 // - TypeExtension: [ConstructorArgument] -> PositionalParameters
  40 // - StaticExtension: almost identical to TypeExtension
  41 // - Reference: [ConstructorArgument], [ContentProperty] -> only ordinal member.
  42 // - ArrayExtension: [ConstrutorArgument], [ContentProperty] -> no PositionalParameters, Items.
  43 // - NullExtension: no member.
  44 // - MyExtension: [ConstructorArgument] -> only ordinal members...hmm?
  45
  46 namespace MonoTests.System.Xaml
  47 {
  48         [TestFixture]
  49         public class XamlObjectReaderTest
  50         {
  51                 [Test]
  52                 public void ConstructorNullObject ()
  53                 {
  54                         // allowed.
  55                         new XamlObjectReader (null);
  56                 }
  57
  58                 [Test]
  59                 [ExpectedException (typeof (ArgumentNullException))]
  60                 public void ConstructorNullSchemaContext ()
  61                 {
  62                         new XamlObjectReader ("foo", (XamlSchemaContext) null);
  63                 }
  64
  65                 [Test]
  66                 public void ConstructorNullSettings ()
  67                 {
  68                         new XamlObjectReader ("foo", (XamlObjectReaderSettings) null);
  69                 }
  70
  71                 [Test]
  72                 [ExpectedException (typeof (ArgumentNullException))]
  73                 public void ConstructorNullSchemaContext2 ()
  74                 {
  75                         new XamlObjectReader ("foo", null, new XamlObjectReaderSettings ());
  76                 }
  77
  78                 [Test]
  79                 public void ConstructorNullSettings2 ()
  80                 {
  81                         new XamlObjectReader ("foo", new XamlSchemaContext (null, null), null);
  82                 }
  83
  84                 [Test]
  85                 public void ReadNull ()
  86                 {
  87                         var r = new XamlObjectReader (null);
  88                         Assert.IsTrue (r.Read (), "#1");
  89                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-2");
  90                         Assert.IsTrue (r.Read (), "#2");
  91                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-2");
  92                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#2-3");
  93                         Assert.IsTrue (r.Read (), "#3");
  94                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#3-2");
  95                         Assert.IsFalse (r.Read (), "#4");
  96                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#4-2");
  97                 }
  98
  99                 [Test]
 100                 public void Read1 ()
 101                 {
 102                         var r = new XamlObjectReader ("Foo");
 103                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 104                         Assert.IsNull (r.Member, "#2");
 105                         Assert.IsNull (r.Namespace, "#3");
 106                         Assert.IsNull (r.Member, "#4");
 107                         Assert.IsNull (r.Type, "#5");
 108                         Assert.IsNull (r.Value, "#6");
 109
 110                         Assert.IsTrue (r.Read (), "#11");
 111                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 112                         Assert.IsNotNull (r.Namespace, "#13");
 113                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 114                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 115
 116                         Assert.IsTrue (r.Read (), "#21");
 117                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 118                         Assert.IsNotNull (r.Type, "#23");
 119                         Assert.AreEqual (new XamlType (typeof (string), r.SchemaContext), r.Type, "#23-2");
 120                         Assert.IsNull (r.Namespace, "#25");
 121
 122                         Assert.IsTrue (r.Read (), "#31");
 123                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 124                         Assert.IsNotNull (r.Member, "#33");
 125                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#33-2");
 126                         Assert.IsNull (r.Type, "#34");
 127
 128                         Assert.IsTrue (r.Read (), "#41");
 129                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 130                         Assert.AreEqual ("Foo", r.Value, "#43");
 131                         Assert.IsNull (r.Member, "#44");
 132
 133                         Assert.IsTrue (r.Read (), "#51");
 134                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 135                         Assert.IsNull (r.Type, "#53");
 136                         Assert.IsNull (r.Member, "#54");
 137
 138                         Assert.IsTrue (r.Read (), "#61");
 139                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 140                         Assert.IsNull (r.Type, "#63");
 141
 142                         Assert.IsFalse (r.Read (), "#71");
 143                         Assert.IsTrue (r.IsEof, "#72");
 144                 }
 145
 146                 [Test]
 147                 [ExpectedException (typeof (XamlObjectReaderException))]
 148                 public void ReadNonConstructible ()
 149                 {
 150                         // XamlType has no default constructor.
 151                         var r = new XamlObjectReader (XamlLanguage.String);
 152                 }
 153
 154                 [Test]
 155                 [ExpectedException (typeof (XamlObjectReaderException))]
 156                 public void NonPublicType ()
 157                 {
 158                         new XamlObjectReader (new TestClass1 ());
 159                 }
 160
 161                 [Test]
 162                 [ExpectedException (typeof (XamlObjectReaderException))]
 163                 public void NestedType ()
 164                 {
 165                         new XamlObjectReader (new TestClass2 ());
 166                 }
 167
 168                 public class TestClass2
 169                 {
 170                 }
 171
 172                 [Test]
 173                 public void ConstructibleType ()
 174                 {
 175                         new XamlObjectReader (new TestClass3 ());
 176                 }
 177
 178                 [Test]
 179                 public void WriteNullMemberAsObject ()
 180                 {
 181                         var r = new XamlObjectReader (new TestClass4 ());
 182
 183                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 184                         Assert.IsTrue (r.Read (), "#6");
 185                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
 186                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#7-2");
 187                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "#7-3");
 188
 189                         Assert.IsTrue (r.Read (), "#11");
 190                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 191                         Assert.AreEqual ("x", r.Namespace.Prefix, "#12-2");
 192                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#12-3");
 193
 194                         Assert.IsTrue (r.Read (), "#16");
 195                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#17");
 196                         var xt = new XamlType (typeof (TestClass4), r.SchemaContext);
 197                         Assert.AreEqual (xt, r.Type, "#17-2");
 198                         Assert.IsTrue (r.Instance is TestClass4, "#17-3");
 199                         Assert.AreEqual (2, xt.GetAllMembers ().Count, "#17-4");
 200
 201                         Assert.IsTrue (r.Read (), "#21");
 202                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#22");
 203                         Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#22-2");
 204
 205                         Assert.IsTrue (r.Read (), "#26");
 206                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#27");
 207                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#27-2");
 208                         Assert.IsNull (r.Instance, "#27-3");
 209
 210                         Assert.IsTrue (r.Read (), "#31");
 211                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#32");
 212
 213                         Assert.IsTrue (r.Read (), "#36");
 214                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#37");
 215
 216                         Assert.IsTrue (r.Read (), "#41");
 217                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#42");
 218                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#42-2");
 219
 220                         Assert.IsTrue (r.Read (), "#43");
 221                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#43-2");
 222                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#43-3");
 223                         Assert.IsNull (r.Instance, "#43-4");
 224
 225                         Assert.IsTrue (r.Read (), "#44");
 226                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#44-2");
 227
 228                         Assert.IsTrue (r.Read (), "#46");
 229                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#47");
 230
 231                         Assert.IsTrue (r.Read (), "#51");
 232                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#52");
 233
 234                         Assert.IsFalse (r.Read (), "#56");
 235                         Assert.IsTrue (r.IsEof, "#57");
 236                 }
 237
 238                 [Test]
 239                 public void StaticMember ()
 240                 {
 241                         var r = new XamlObjectReader (new TestClass5 ());
 242
 243                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 244                         Assert.IsTrue (r.Read (), "#6");
 245                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
 246                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#7-2");
 247                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "#7-3");
 248
 249                         Assert.IsTrue (r.Read (), "#11");
 250                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 251                         Assert.AreEqual ("x", r.Namespace.Prefix, "#12-2");
 252                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#12-3");
 253
 254                         Assert.IsTrue (r.Read (), "#16");
 255                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#17");
 256                         var xt = new XamlType (typeof (TestClass5), r.SchemaContext);
 257                         Assert.AreEqual (xt, r.Type, "#17-2");
 258                         Assert.IsTrue (r.Instance is TestClass5, "#17-3");
 259                         Assert.AreEqual (2, xt.GetAllMembers ().Count, "#17-4");
 260                         Assert.IsTrue (xt.GetAllMembers ().Any (xm => xm.Name == "Bar"), "#17-5");
 261                         Assert.IsTrue (xt.GetAllMembers ().Any (xm => xm.Name == "Baz"), "#17-6");
 262
 263                         Assert.IsTrue (r.Read (), "#21");
 264                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#22");
 265                         Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#22-2");
 266
 267                         Assert.IsTrue (r.Read (), "#26");
 268                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#27");
 269                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#27-2");
 270                         Assert.IsNull (r.Instance, "#27-3");
 271
 272                         Assert.IsTrue (r.Read (), "#31");
 273                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#32");
 274
 275                         Assert.IsTrue (r.Read (), "#36");
 276                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#37");
 277                         // static Foo is not included in GetAllXembers() return value.
 278                         // nonpublic Baz does not appear either.
 279
 280                         Assert.IsTrue (r.Read (), "#51");
 281                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#52");
 282
 283                         Assert.IsFalse (r.Read (), "#56");
 284                         Assert.IsTrue (r.IsEof, "#57");
 285                 }
 286
 287                 [Test]
 288                 public void Skip ()
 289                 {
 290                         var r = new XamlObjectReader ("Foo");
 291                         r.Skip ();
 292                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 293                         r.Skip ();
 294                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2");
 295                         r.Skip ();
 296                         Assert.IsTrue (r.IsEof, "#3");
 297                 }
 298
 299                 [Test]
 300                 public void Skip2 ()
 301                 {
 302                         var r = new XamlObjectReader ("Foo");
 303                         r.Read (); // NamespaceDeclaration
 304                         r.Read (); // Type
 305                         r.Read (); // Member (Initialization)
 306                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#1");
 307                         r.Skip ();
 308                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#2");
 309                         r.Skip ();
 310                         Assert.IsTrue (r.IsEof, "#3");
 311                 }
 312
 313                 [Test]
 314                 public void Read2 ()
 315                 {
 316                         var doc = new XmlDocument ();
 317                         doc.LoadXml ("<root xmlns='urn:foo'><elem attr='val' /></root>");
 318                         var r = new XamlObjectReader (doc);
 319
 320                         for (int i = 0; i < 3; i++) {
 321                                 r.Read ();
 322                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-" + i);
 323                         }
 324                         r.Read ();
 325
 326                         Assert.AreEqual (new XamlType (typeof (XmlDocument), r.SchemaContext), r.Type, "#2");
 327                         r.Read ();
 328                         var l = new List<XamlMember> ();
 329                         for (int i = 0; i < 5; i++) {
 330                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-" + i);
 331                                 l.Add (r.Member);
 332                                 r.Skip ();
 333                         }
 334                         l.First (m => m.Name == "Value");
 335                         l.First (m => m.Name == "InnerXml");
 336                         l.First (m => m.Name == "Prefix");
 337                         l.First (m => m.Name == "PreserveWhitespace");
 338                         l.First (m => m.Name == "Schemas");
 339                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#4");
 340                         Assert.IsFalse (r.Read (), "#5");
 341                 }
 342
 343                 [Test]
 344                 public void Read_NonPrimitive ()
 345                 {
 346                         var r = new XamlObjectReader (new TestClass3 ());
 347                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 348                         Assert.IsTrue (r.Read (), "#6");
 349                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
 350                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#7-2");
 351                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "#7-3");
 352
 353                         Assert.IsTrue (r.Read (), "#11");
 354                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 355                         Assert.AreEqual ("x", r.Namespace.Prefix, "#12-2");
 356                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#12-3");
 357
 358                         Assert.IsTrue (r.Read (), "#16");
 359                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#17");
 360                         var xt = new XamlType (typeof (TestClass3), r.SchemaContext);
 361                         Assert.AreEqual (xt, r.Type, "#17-2");
 362                         Assert.IsTrue (r.Instance is TestClass3, "#17-3");
 363
 364                         Assert.IsTrue (r.Read (), "#21");
 365                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#22");
 366                         Assert.AreEqual (xt.GetMember ("Nested"), r.Member, "#22-2");
 367
 368                         Assert.IsTrue (r.Read (), "#26");
 369                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#27");
 370                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#27-2");
 371                         Assert.IsNull (r.Instance, "#27-3");
 372
 373                         Assert.IsTrue (r.Read (), "#31");
 374                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#32");
 375
 376                         Assert.IsTrue (r.Read (), "#36");
 377                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#37");
 378
 379                         Assert.IsTrue (r.Read (), "#41");
 380                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#42");
 381
 382                         Assert.IsFalse (r.Read (), "#46");
 383                         Assert.IsTrue (r.IsEof, "#47");
 384                 }
 385
 386                 [Test]
 387                 public void Read_Type ()
 388                 {
 389                         var r = new XamlObjectReader (typeof (int));
 390                         Read_TypeOrTypeExtension (r, typeof (int));
 391                 }
 392
 393                 [Test]
 394                 public void Read_TypeExtension ()
 395                 {
 396                         var tx = new TypeExtension (typeof (int));
 397                         var r = new XamlObjectReader (tx);
 398                         Read_TypeOrTypeExtension (r, tx);
 399                 }
 400
 401                 void Read_TypeOrTypeExtension (XamlObjectReader r, object obj)
 402                 {
 403                         Assert.IsTrue (r.Read (), "#11");
 404                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 405                         Assert.IsNotNull (r.Namespace, "#13");
 406                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 407                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 408                         Assert.IsNull (r.Instance, "#14");
 409
 410                         Assert.IsTrue (r.Read (), "#21");
 411                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 412                         Assert.IsNotNull (r.Type, "#23");
 413                         Assert.AreEqual (new XamlType (typeof (TypeExtension), r.SchemaContext), r.Type, "#23-2");
 414                         Assert.IsNull (r.Namespace, "#25");
 415                         Assert.IsTrue (r.Instance is TypeExtension, "#26");
 416
 417                         Assert.IsTrue (r.Read (), "#31");
 418                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 419                         Assert.IsNotNull (r.Member, "#33");
 420                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 421                         Assert.IsNull (r.Type, "#34");
 422                         Assert.IsNull (r.Instance, "#35");
 423
 424                         Assert.IsTrue (r.Read (), "#41");
 425                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 426                         Assert.IsNotNull (r.Value, "#43");
 427                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 428                         Assert.IsNull (r.Member, "#44");
 429                         Assert.IsNull (r.Instance, "#45");
 430
 431                         Assert.IsTrue (r.Read (), "#51");
 432                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 433                         Assert.IsNull (r.Type, "#53");
 434                         Assert.IsNull (r.Member, "#54");
 435                         Assert.IsNull (r.Instance, "#55");
 436
 437                         Assert.IsTrue (r.Read (), "#61");
 438                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 439                         Assert.IsNull (r.Type, "#63");
 440
 441                         Assert.IsFalse (r.Read (), "#71");
 442                         Assert.IsTrue (r.IsEof, "#72");
 443                 }
 444
 445                 [Test]
 446                 public void Read_Type2 ()
 447                 {
 448                         var r = new XamlObjectReader (typeof (TestClass1));
 449                         Read_TypeOrTypeExtension2 (r);
 450                 }
 451
 452                 [Test]
 453                 public void Read_TypeExtension2 ()
 454                 {
 455                         var r = new XamlObjectReader (new TypeExtension (typeof (TestClass1)));
 456                         Read_TypeOrTypeExtension2 (r);
 457                 }
 458
 459                 void Read_TypeOrTypeExtension2 (XamlObjectReader r)
 460                 {
 461                         Assert.IsTrue (r.Read (), "#11");
 462                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 463
 464                         var defns = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name;
 465
 466                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#13-2");
 467                         Assert.AreEqual (defns, r.Namespace.Namespace, "#13-3:" + r.Namespace.Prefix);
 468
 469                         Assert.IsTrue (r.Read (), "#16");
 470                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#17");
 471                         Assert.IsNotNull (r.Namespace, "#18");
 472                         Assert.AreEqual ("x", r.Namespace.Prefix, "#18-2");
 473                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#18-3:" + r.Namespace.Prefix);
 474
 475                         Assert.IsTrue (r.Read (), "#21");
 476                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 477                         Assert.AreEqual (new XamlType (typeof (TypeExtension), r.SchemaContext), r.Type, "#23-2");
 478                         Assert.IsTrue (r.Instance is TypeExtension, "#26");
 479
 480                         Assert.IsTrue (r.Read (), "#31");
 481                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 482                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 483
 484                         Assert.IsTrue (r.Read (), "#41");
 485                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 486                         Assert.AreEqual ("TestClass1", 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                 [Test]
 499                 public void Read_Reference ()
 500                 {
 501                         var r = new XamlObjectReader (new Reference ("TestName"));
 502                         Assert.IsTrue (r.Read (), "#11");
 503                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 504                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 505                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 506
 507                         Assert.IsTrue (r.Read (), "#21");
 508                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 509                         var xt = new XamlType (typeof (Reference), r.SchemaContext);
 510                         Assert.AreEqual (xt, r.Type, "#23-2");
 511                         Assert.IsTrue (r.Instance is Reference, "#26");
 512
 513                         Assert.IsTrue (r.Read (), "#31");
 514                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 515                         // unlike TypeExtension there is no PositionalParameters.
 516                         Assert.AreEqual (xt.GetMember ("Name"), r.Member, "#33-2");
 517
 518                         // It is a ContentProperty (besides [ConstructorArgument])
 519                         Assert.IsTrue (r.Read (), "#41");
 520                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 521                         Assert.AreEqual ("TestName", r.Value, "#43-2");
 522
 523                         Assert.IsTrue (r.Read (), "#51");
 524                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 525
 526                         Assert.IsTrue (r.Read (), "#61");
 527                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 528
 529                         Assert.IsFalse (r.Read (), "#71");
 530                         Assert.IsTrue (r.IsEof, "#72");
 531                 }
 532
 533
 534                 [Test]
 535                 public void Read_Null ()
 536                 {
 537                         var r = new XamlObjectReader (null);
 538                         Read_NullOrNullExtension (r, null);
 539                 }
 540
 541                 [Test]
 542                 public void Read_NullExtension ()
 543                 {
 544                         var o = new NullExtension ();
 545                         var r = new XamlObjectReader (o);
 546                         Read_NullOrNullExtension (r, o);
 547                 }
 548
 549                 void Read_NullOrNullExtension (XamlObjectReader r, object instance)
 550                 {
 551                         Assert.IsTrue (r.Read (), "#11");
 552                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 553                         Assert.IsNotNull (r.Namespace, "#13");
 554                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 555                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 556                         Assert.IsNull (r.Instance, "#14");
 557
 558                         Assert.IsTrue (r.Read (), "#21");
 559                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 560                         Assert.AreEqual (new XamlType (typeof (NullExtension), r.SchemaContext), r.Type, "#23-2");
 561                         Assert.AreEqual (instance, r.Instance, "#26"); // null and NullExtension are different here.
 562
 563                         Assert.IsTrue (r.Read (), "#61");
 564                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 565
 566                         Assert.IsFalse (r.Read (), "#71");
 567                         Assert.IsTrue (r.IsEof, "#72");
 568                 }
 569
 570                 [Test] // almost identical to TypeExtension (only type/instance difference)
 571                 public void Read_StaticExtension ()
 572                 {
 573                         var r = new XamlObjectReader (new StaticExtension ("MyMember"));
 574                         Assert.IsTrue (r.Read (), "#11");
 575                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 576                         Assert.IsNotNull (r.Namespace, "#13");
 577                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 578                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 579                         Assert.IsNull (r.Instance, "#14");
 580
 581                         Assert.IsTrue (r.Read (), "#21");
 582                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 583                         Assert.AreEqual (new XamlType (typeof (StaticExtension), r.SchemaContext), r.Type, "#23-2");
 584                         Assert.IsTrue (r.Instance is StaticExtension, "#26");
 585
 586                         Assert.IsTrue (r.Read (), "#31");
 587                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 588                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 589
 590                         Assert.IsTrue (r.Read (), "#41");
 591                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 592                         Assert.AreEqual ("MyMember", r.Value, "#43-2");
 593
 594                         Assert.IsTrue (r.Read (), "#51");
 595                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 596
 597                         Assert.IsTrue (r.Read (), "#61");
 598                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 599
 600                         Assert.IsFalse (r.Read (), "#71");
 601                         Assert.IsTrue (r.IsEof, "#72");
 602                 }
 603
 604                 [Test]
 605                 public void Read_ListInt32 ()
 606                 {
 607                         var obj = new List<int> (new int [] {5, -3, 0});
 608
 609                         var r = new XamlObjectReader (obj);
 610                         Assert.IsTrue (r.Read (), "ns#1-1");
 611                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
 612
 613                         var defns = "clr-namespace:System.Collections.Generic;assembly=mscorlib";
 614
 615                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3");
 616                         Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4");
 617
 618                         Assert.IsTrue (r.Read (), "#11");
 619                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 620                         Assert.IsNotNull (r.Namespace, "#13");
 621                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 622                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 623
 624                         Assert.IsTrue (r.Read (), "#21");
 625                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 626                         var xt = new XamlType (typeof (List<int>), r.SchemaContext);
 627                         Assert.AreEqual (xt, r.Type, "#23");
 628                         Assert.AreEqual (obj, r.Instance, "#26");
 629                         Assert.IsTrue (xt.IsCollection, "#27");
 630
 631                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 632
 633                         Assert.IsTrue (r.Read (), "#31");
 634                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 635                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
 636
 637                         Assert.IsTrue (r.Read (), "#41");
 638                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 639                         // The value is implementation details, not testable.
 640                         //Assert.AreEqual ("3", r.Value, "#43");
 641
 642                         Assert.IsTrue (r.Read (), "#51");
 643                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 644
 645                         Assert.IsTrue (r.Read (), "#72");
 646                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 647                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 648
 649                         string [] values = {"5", "-3", "0"};
 650                         for (int i = 0; i < 3; i++) {
 651                                 Assert.IsTrue (r.Read (), i + "#73");
 652                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 653                                 Assert.IsTrue (r.Read (), i + "#74");
 654                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 655                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 656                                 Assert.IsTrue (r.Read (), i + "#75");
 657                                 Assert.IsNotNull (r.Value, i + "#75-2");
 658                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 659                                 Assert.IsTrue (r.Read (), i + "#74");
 660                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 661                                 Assert.IsTrue (r.Read (), i + "#75");
 662                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 663                         }
 664
 665                         Assert.IsTrue (r.Read (), "#81");
 666                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 667
 668                         Assert.IsTrue (r.Read (), "#87");
 669                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ArrayExtension
 670
 671                         Assert.IsFalse (r.Read (), "#89");
 672                 }
 673
 674                 [Test]
 675                 public void Read_Array ()
 676                 {
 677                         var obj = new int [] {5, -3, 0};
 678                         var r = new XamlObjectReader (obj);
 679                         Read_ArrayOrArrayExtension (r, obj);
 680                 }
 681
 682                 [Test]
 683                 public void Read_ArrayExtension ()
 684                 {
 685                         var obj = new ArrayExtension (new int [] {5, -3, 0});
 686                         var r = new XamlObjectReader (obj);
 687                         Read_ArrayOrArrayExtension (r, obj);
 688                 }
 689
 690                 void Read_ArrayOrArrayExtension (XamlObjectReader r, object instance)
 691                 {
 692                         Assert.IsTrue (r.Read (), "#11");
 693                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 694                         Assert.IsNotNull (r.Namespace, "#13");
 695                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 696                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 697
 698                         Assert.IsTrue (r.Read (), "#21");
 699                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 700                         var xt = new XamlType (typeof (ArrayExtension), r.SchemaContext);
 701                         Assert.AreEqual (xt, r.Type, "#23");
 702                         Assert.AreEqual (instance, r.Instance, "#26"); // different between Array and ArrayExtension. Also, different from Type and TypeExtension (Type returns TypeExtension, while Array remains to return Array)
 703
 704                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 705
 706                         Assert.IsTrue (r.Read (), "#31");
 707                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 708                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33");
 709
 710                         Assert.IsTrue (r.Read (), "#41");
 711                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 712                         Assert.AreEqual ("x:Int32", r.Value, "#43");
 713
 714                         Assert.IsTrue (r.Read (), "#51");
 715                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 716
 717                         Assert.IsTrue (r.Read (), "#61");
 718                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
 719                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
 720
 721                         Assert.IsTrue (r.Read (), "#71");
 722                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
 723                         Assert.IsNull (r.Type, "#71-3");
 724                         Assert.IsNull (r.Member, "#71-4");
 725                         Assert.IsNull (r.Value, "#71-5");
 726
 727                         Assert.IsTrue (r.Read (), "#72");
 728                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 729                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 730
 731                         string [] values = {"5", "-3", "0"};
 732                         for (int i = 0; i < 3; i++) {
 733                                 Assert.IsTrue (r.Read (), i + "#73");
 734                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 735                                 Assert.IsTrue (r.Read (), i + "#74");
 736                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 737                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 738                                 Assert.IsTrue (r.Read (), i + "#75");
 739                                 Assert.IsNotNull (r.Value, i + "#75-2");
 740                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 741                                 Assert.IsTrue (r.Read (), i + "#74");
 742                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 743                                 Assert.IsTrue (r.Read (), i + "#75");
 744                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 745                         }
 746
 747                         Assert.IsTrue (r.Read (), "#81");
 748                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 749
 750                         Assert.IsTrue (r.Read (), "#83");
 751                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
 752
 753                         Assert.IsTrue (r.Read (), "#85");
 754                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ArrayExtension.Items
 755
 756                         Assert.IsTrue (r.Read (), "#87");
 757                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ArrayExtension
 758
 759                         Assert.IsFalse (r.Read (), "#89");
 760                 }
 761
 762                 [Test] // It gives Type member, not PositionalParameters... and no Items member here.
 763                 public void Read_ArrayExtension2 ()
 764                 {
 765                         var r = new XamlObjectReader (new ArrayExtension (typeof (int)));
 766                         Assert.IsTrue (r.Read (), "#11");
 767                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 768                         Assert.IsNotNull (r.Namespace, "#13");
 769                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 770                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 771                         Assert.IsNull (r.Instance, "#14");
 772
 773                         Assert.IsTrue (r.Read (), "#21");
 774                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 775                         var xt = new XamlType (typeof (ArrayExtension), r.SchemaContext);
 776                         Assert.AreEqual (xt, r.Type, "#23-2");
 777                         Assert.IsTrue (r.Instance is ArrayExtension, "#26");
 778
 779                         Assert.IsTrue (r.Read (), "#31");
 780                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 781                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33-2");
 782
 783                         Assert.IsTrue (r.Read (), "#41");
 784                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 785                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 786
 787                         Assert.IsTrue (r.Read (), "#51");
 788                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 789
 790                         Assert.IsTrue (r.Read (), "#61");
 791                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 792
 793                         Assert.IsFalse (r.Read (), "#71");
 794                         Assert.IsTrue (r.IsEof, "#72");
 795                 }
 796
 797                 [Test]
 798                 public void Read_DateTime ()
 799                 {
 800                         var obj = new DateTime (2010, 4, 15);
 801                         var r = new XamlObjectReader (obj);
 802                         Read_CommonClrType (r, obj);
 803                         Assert.AreEqual ("2010-04-15", Read_Initialization (r, null), "#1");
 804                 }
 805
 806                 [Test]
 807                 public void Read_TimeSpan ()
 808                 {
 809                         Read_CommonXamlPrimitive (TimeSpan.FromMinutes (4));
 810                 }
 811
 812                 [Test]
 813                 public void Read_Uri ()
 814                 {
 815                         Read_CommonXamlPrimitive (new Uri ("urn:foo"));
 816                 }
 817
 818                 [Test]
 819                 public void Read_Guid ()
 820                 {
 821                         var obj = Guid.NewGuid ();
 822                         var r = new XamlObjectReader (obj);
 823                         Assert.IsNotNull (r.SchemaContext.GetXamlType (typeof (Guid)).TypeConverter, "premise#1");
 824                         Read_CommonClrType (r, obj);
 825                         Assert.AreEqual (obj.ToString (), Read_Initialization (r, null), "#1");
 826                 }
 827
 828                 [Test]
 829                 [ExpectedException (typeof (XamlObjectReaderException))]
 830                 [Category ("NotWorking")]
 831                 public void Read_XData ()
 832                 {
 833                         var r = new XamlObjectReader (new XData () {Text = "xdata text"}); // XmlReader implementation is not visible.
 834                         while (!r.IsEof)
 835                                 r.Read ();
 836                 }
 837
 838                 [Test]
 839                 public void ReadStandardTypes ()
 840                 {
 841                         SimpleReadStandardType (new ArrayExtension ());
 842                         SimpleReadStandardType (new NullExtension ());
 843                         SimpleReadStandardType (new PropertyDefinition ());
 844                         SimpleReadStandardType (new Reference ());
 845                         SimpleReadStandardType (new StaticExtension ());
 846                         SimpleReadStandardType (new TypeExtension ());
 847                 }
 848
 849                 [Test]
 850                 public void Read_CustomMarkupExtension ()
 851                 {
 852                         var r = new XamlObjectReader (new MyExtension () { Foo = typeof (int), Bar = "v2", Baz = "v7"});
 853                         r.Read (); // ns
 854                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 855                         r.Read (); // ns
 856                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-2");
 857                         r.Read ();
 858                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
 859                         Assert.IsFalse (r.IsEof, "#1");
 860                         var xt = r.Type;
 861
 862                         r.Read ();
 863                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#2-1");
 864                         Assert.IsFalse (r.IsEof, "#2-2");
 865                         Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#2-3");
 866
 867                         Assert.IsTrue (r.Read (), "#2-4");
 868                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#2-5");
 869                         Assert.AreEqual ("v2", r.Value, "#2-6");
 870
 871                         Assert.IsTrue (r.Read (), "#2-7");
 872                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#2-8");
 873
 874                         r.Read ();
 875                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-1");
 876                         Assert.IsFalse (r.IsEof, "#3-2");
 877                         Assert.AreEqual (xt.GetMember ("Baz"), r.Member, "#3-3");
 878
 879                         Assert.IsTrue (r.Read (), "#3-4");
 880                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#3-5");
 881                         Assert.AreEqual ("v7", r.Value, "#3-6");
 882
 883                         Assert.IsTrue (r.Read (), "#3-7");
 884                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#3-8");
 885
 886                         r.Read ();
 887                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#4-1");
 888                         Assert.IsFalse (r.IsEof, "#4-2");
 889                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4-3");
 890                         Assert.IsTrue (r.Read (), "#4-4");
 891                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#4-5");
 892                         Assert.AreEqual ("x:Int32", r.Value, "#4-6");
 893
 894                         Assert.IsTrue (r.Read (), "#4-7");
 895                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#4-8");
 896
 897                         Assert.IsTrue (r.Read (), "#5");
 898                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#5-2");
 899
 900                         Assert.IsFalse (r.Read (), "#6");
 901                 }
 902
 903                 [Test]
 904                 public void Read_CustomMarkupExtension2 ()
 905                 {
 906                         var r = new XamlObjectReader (new MyExtension2 () { Foo = typeof (int), Bar = "v2"});
 907                         r.Read (); // ns
 908                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 909                         r.Read (); // note that there wasn't another NamespaceDeclaration.
 910                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
 911                         var xt = r.Type;
 912                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension2)), xt, "#2");
 913                         Assert.IsTrue (r.Read (), "#3");
 914                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
 915                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
 916                         Assert.IsTrue (r.Read (), "#5");
 917                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension2", r.Value, "#6");
 918                         Assert.IsTrue (r.Read (), "#7"); // EndMember
 919                         Assert.IsTrue (r.Read (), "#8"); // EndObject
 920                         Assert.IsFalse (r.Read (), "#9");
 921                 }
 922
 923                 [Test]
 924                 public void Read_CustomMarkupExtension3 ()
 925                 {
 926                         var r = new XamlObjectReader (new MyExtension3 () { Foo = typeof (int), Bar = "v2"});
 927                         r.Read (); // ns
 928                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 929                         r.Read (); // note that there wasn't another NamespaceDeclaration.
 930                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
 931                         var xt = r.Type;
 932                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension3)), xt, "#2");
 933                         Assert.IsTrue (r.Read (), "#3");
 934                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
 935                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
 936                         Assert.IsTrue (r.Read (), "#5");
 937                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension3", r.Value, "#6");
 938                         Assert.IsTrue (r.Read (), "#7"); // EndMember
 939                         Assert.IsTrue (r.Read (), "#8"); // EndObject
 940                         Assert.IsFalse (r.Read (), "#9");
 941                 }
 942
 943                 [Test]
 944                 public void Read_CustomMarkupExtension4 ()
 945                 {
 946                         var r = new XamlObjectReader (new MyExtension4 () { Foo = typeof (int), Bar = "v2"});
 947                         r.Read (); // ns
 948                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 949                         r.Read (); // note that there wasn't another NamespaceDeclaration.
 950                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
 951                         var xt = r.Type;
 952                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension4)), xt, "#2");
 953                         Assert.IsTrue (r.Read (), "#3");
 954                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
 955                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
 956                         Assert.IsTrue (r.Read (), "#5");
 957                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension4", r.Value, "#6");
 958                         Assert.IsTrue (r.Read (), "#7"); // EndMember
 959                         Assert.IsTrue (r.Read (), "#8"); // EndObject
 960                         Assert.IsFalse (r.Read (), "#9");
 961                 }
 962
 963                 [Test]
 964                 [Category ("NotWorking")]
 965                 public void Read_CustomMarkupExtension5 ()
 966                 {
 967                         // This cannot be written to XamlXmlWriter though...
 968
 969                         var r = new XamlObjectReader (new MyExtension5 ("foo", "bar"));
 970                         r.Read (); // ns
 971                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 972                         r.Read (); // note that there wasn't another NamespaceDeclaration.
 973                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
 974                         var xt = r.Type;
 975                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension5)), xt, "#2");
 976                         Assert.IsTrue (r.Read (), "#3");
 977                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
 978                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#4");
 979                         Assert.IsTrue (r.Read (), "#5");
 980                         Assert.AreEqual ("foo", r.Value, "#6");
 981                         Assert.IsTrue (r.Read (), "#7");
 982                         Assert.AreEqual ("bar", r.Value, "#8");
 983                         Assert.IsTrue (r.Read (), "#9");
 984                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#10");
 985                         Assert.IsTrue (r.Read (), "#11");
 986                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#12");
 987                         Assert.IsFalse (r.Read (), "#13");
 988                 }
 989
 990                 [Test]
 991                 [Category ("NotWorking")]
 992                 public void Read_CustomMarkupExtension6 ()
 993                 {
 994                         var r = new XamlObjectReader (new MyExtension6 ("foo"));
 995                         r.Read (); // ns
 996                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 997                         r.Read (); // note that there wasn't another NamespaceDeclaration.
 998                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
 999                         var xt = r.Type;
1000                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension6)), xt, "#2");
1001                         Assert.IsTrue (r.Read (), "#3");
1002                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1003                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4"); // this is the difference between MyExtension5 and MyExtension6: it outputs constructor arguments as normal members
1004                         Assert.IsTrue (r.Read (), "#5");
1005                         Assert.AreEqual ("foo", r.Value, "#6");
1006                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1007                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1008                         Assert.IsFalse (r.Read (), "#9");
1009                 }
1010
1011                 [Test]
1012                 public void Read_ArgumentAttributed ()
1013                 {
1014                         var obj = new ArgumentAttributed ("foo", "bar");
1015                         var r = new XamlObjectReader (obj);
1016                         Read_CommonClrType (r, obj, new KeyValuePair<string,string> ("x", XamlLanguage.Xaml2006Namespace));
1017                         var args = Read_AttributedArguments_String (r, new string [] {"arg1", "arg2"});
1018                         Assert.AreEqual ("foo", args [0], "#1");
1019                         Assert.AreEqual ("bar", args [1], "#2");
1020                 }
1021
1022                 [Test]
1023                 public void Read_Dictionary ()
1024                 {
1025                         var obj = new Dictionary<string,object> ();
1026                         obj ["Foo"] = 5.0;
1027                         obj ["Bar"] = -6.5;
1028                         var r = new XamlObjectReader (obj);
1029
1030                         Assert.IsTrue (r.Read (), "ns#1-1");
1031                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1032                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1033                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1034                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "ns#1-5");
1035
1036                         Assert.IsTrue (r.Read (), "ns#2-1");
1037                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1038                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1039                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1040                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1041
1042                         Assert.IsTrue (r.Read (), "so#1-1");
1043                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1044                         var xt = new XamlType (typeof (Dictionary<string,object>), r.SchemaContext);
1045                         Assert.AreEqual (xt, r.Type, "so#1-3");
1046                         Assert.AreEqual (obj, r.Instance, "so#1-4");
1047
1048                         Assert.IsTrue (r.Read (), "smitems#1");
1049                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smitems#2");
1050                         Assert.AreEqual (XamlLanguage.Items, r.Member, "smitems#3");
1051
1052                         for (int i = 0; i < 2; i++) {
1053
1054                                 // start of an item
1055                                 Assert.IsTrue (r.Read (), "soi#1-1." + i);
1056                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "soi#1-2." + i);
1057                                 var xt2 = new XamlType (typeof (double), r.SchemaContext);
1058                                 Assert.AreEqual (xt2, r.Type, "soi#1-3." + i);
1059
1060                                 Assert.IsTrue (r.Read (), "smi#1-1." + i);
1061                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#1-2." + i);
1062                                 Assert.AreEqual (XamlLanguage.Key, r.Member, "smi#1-3." + i);
1063
1064                                 Assert.IsTrue (r.Read (), "svi#1-1." + i);
1065                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#1-2." + i);
1066                                 Assert.AreEqual (i == 0 ? "Foo" : "Bar", r.Value, "svi#1-3." + i);
1067
1068                                 Assert.IsTrue (r.Read (), "emi#1-1." + i);
1069                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#1-2." + i);
1070
1071                                 Assert.IsTrue (r.Read (), "smi#2-1." + i);
1072                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#2-2." + i);
1073                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, "smi#2-3." + i);
1074
1075                                 Assert.IsTrue (r.Read (), "svi#2-1." + i);
1076                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#2-2." + i);
1077                                 Assert.AreEqual (i == 0 ? "5" : "-6.5", r.Value, "svi#2-3." + i); // converted to string(!)
1078
1079                                 Assert.IsTrue (r.Read (), "emi#2-1." + i);
1080                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#2-2." + i);
1081
1082                                 Assert.IsTrue (r.Read (), "eoi#1-1." + i);
1083                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eoi#1-2." + i);
1084                                 // end of an item
1085                         }
1086
1087                         Assert.IsTrue (r.Read (), "emitems#1");
1088                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emitems#2"); // XamlLanguage.Items
1089
1090                         Assert.IsTrue (r.Read (), "eo#1-1");
1091                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2"); // Dictionary
1092
1093                         Assert.IsFalse (r.Read (), "end");
1094                 }
1095
1096                 [Test]
1097                 [Category ("NotWorking")]
1098                 public void PositionalParameters1 ()
1099                 {
1100                         // ns1 > T:PositionalParametersClass1 > M:_PositionalParameters > foo > 5 > EM:_PositionalParameters > ET:PositionalParametersClass1
1101
1102                         // Note: this can be read, but cannot be written to XML.
1103                         var obj = new PositionalParametersClass1 ("foo", 5);
1104                         var r = new XamlObjectReader (obj);
1105
1106                         Assert.IsTrue (r.Read (), "ns#1-1");
1107                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1108                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1109                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1110                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1111
1112                         Assert.IsTrue (r.Read (), "so#1-1");
1113                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1114                         var xt = new XamlType (typeof (PositionalParametersClass1), r.SchemaContext);
1115                         Assert.AreEqual (xt, r.Type, "so#1-3");
1116                         Assert.AreEqual (obj, r.Instance, "so#1-4");
1117
1118                         Assert.IsTrue (r.Read (), "sposprm#1");
1119                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1120                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "sposprm#3");
1121
1122                         Assert.IsTrue (r.Read (), "sva#1-1");
1123                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1124                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1125
1126                         Assert.IsTrue (r.Read (), "sva#2-1");
1127                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#2-2");
1128                         Assert.AreEqual ("5", r.Value, "sva#2-3");
1129
1130                         Assert.IsTrue (r.Read (), "eposprm#1");
1131                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2"); // XamlLanguage.PositionalParameters
1132
1133                         Assert.IsTrue (r.Read (), "eo#1-1");
1134                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1135
1136                         Assert.IsFalse (r.Read (), "end");
1137                 }
1138
1139                 [Test]
1140                 [Category ("NotWorking")]
1141                 public void PositionalParameters2 ()
1142                 {
1143                         // ns1 > T:PositionalParametersWrapper > M:Body > T:PositionalParametersClass1 > M:_PositionalParameters > foo > 5 > EM:_PositionalParameters > ET:PositionalParametersClass1
1144
1145                         var obj = new PositionalParametersWrapper ("foo", 5);
1146                         var r = new XamlObjectReader (obj);
1147
1148                         Assert.IsTrue (r.Read (), "ns#1-1");
1149                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1150                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1151                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1152                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1153
1154                         Assert.IsTrue (r.Read (), "so#1-1");
1155                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1156                         var xt = new XamlType (typeof (PositionalParametersWrapper), r.SchemaContext);
1157                         Assert.AreEqual (xt, r.Type, "so#1-3");
1158                         Assert.AreEqual (obj, r.Instance, "so#1-4");
1159
1160                         Assert.IsTrue (r.Read (), "sm#1-1");
1161                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#1-2");
1162                         Assert.AreEqual (xt.GetMember ("Body"), r.Member, "sm#1-3");
1163
1164                         xt = new XamlType (typeof (PositionalParametersClass1), r.SchemaContext);
1165                         Assert.IsTrue (r.Read (), "so#2-1");
1166                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1167                         Assert.AreEqual (xt, r.Type, "so#2-3");
1168                         Assert.AreEqual (obj.Body, r.Instance, "so#2-4");
1169
1170                         Assert.IsTrue (r.Read (), "sposprm#1");
1171                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1172                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "sposprm#3");
1173
1174                         Assert.IsTrue (r.Read (), "sva#1-1");
1175                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1176                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1177
1178                         Assert.IsTrue (r.Read (), "sva#2-1");
1179                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#2-2");
1180                         Assert.AreEqual ("5", r.Value, "sva#2-3");
1181
1182                         Assert.IsTrue (r.Read (), "eposprm#1");
1183                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2"); // XamlLanguage.PositionalParameters
1184
1185                         Assert.IsTrue (r.Read (), "eo#2-1");
1186                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1187
1188                         Assert.IsTrue (r.Read (), "em#1-1");
1189                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eo#1-2");
1190
1191                         Assert.IsTrue (r.Read (), "eo#1-1");
1192                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1193
1194                         Assert.IsFalse (r.Read (), "end");
1195                 }
1196
1197                 [Test]
1198                 [Category ("NotWorking")]
1199                 public void ComplexPositionalParameters ()
1200                 {
1201                         var obj = new ComplexPositionalParameterWrapper () { Param = new ComplexPositionalParameterClass (new ComplexPositionalParameterValue () { Foo = "foo" })};
1202                         var r = new XamlObjectReader (obj);
1203
1204                         Assert.IsTrue (r.Read (), "ns#1-1");
1205                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1206                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1207                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1208                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1209
1210                         Assert.IsTrue (r.Read (), "ns#2-1");
1211                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1212                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1213                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1214                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1215
1216                         Assert.IsTrue (r.Read (), "so#1-1");
1217                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1218                         var xt = new XamlType (obj.GetType (), r.SchemaContext);
1219                         Assert.AreEqual (xt, r.Type, "so#1-3");
1220                         Assert.AreEqual (obj, r.Instance, "so#1-4");
1221
1222                         Assert.IsTrue (r.Read (), "sm#1-1");
1223                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#1-2");
1224                         Assert.AreEqual (xt.GetMember ("Param"), r.Member, "sm#1-3");
1225
1226                         xt = r.SchemaContext.GetXamlType (typeof (ComplexPositionalParameterClass));
1227                         Assert.IsTrue (r.Read (), "so#2-1");
1228                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1229                         Assert.AreEqual (xt, r.Type, "so#2-3");
1230                         Assert.AreEqual (obj.Param, r.Instance, "so#2-4");
1231
1232                         Assert.IsTrue (r.Read (), "sarg#1");
1233                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sarg#2");
1234                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "sarg#3");
1235
1236                         Assert.IsTrue (r.Read (), "so#3-1");
1237                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#3-2");
1238                         xt = r.SchemaContext.GetXamlType (typeof (ComplexPositionalParameterValue));
1239                         Assert.AreEqual (xt, r.Type, "so#3-3");
1240
1241                         Assert.IsTrue (r.Read (), "sm#3-1");
1242                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#3-2");
1243                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "sm#3-3");
1244                         Assert.IsTrue (r.Read (), "v#3-1");
1245                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "v#3-2");
1246                         Assert.AreEqual ("foo", r.Value, "v#3-3");
1247
1248                         Assert.IsTrue (r.Read (), "em#3-1");
1249                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em#3-2");
1250                         Assert.IsTrue (r.Read (), "eo#3-1");
1251                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#3-2");
1252
1253                         Assert.IsTrue (r.Read (), "earg#1");
1254                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "earg#2"); // XamlLanguage.Arguments
1255
1256                         Assert.IsTrue (r.Read (), "eo#2-1");
1257                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1258
1259                         Assert.IsTrue (r.Read (), "em#1-1");
1260                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eo#1-2");
1261
1262                         Assert.IsTrue (r.Read (), "eo#1-1");
1263                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1264
1265                         Assert.IsFalse (r.Read (), "end");
1266                 }
1267
1268                 void SimpleReadStandardType (object instance)
1269                 {
1270                         var r = new XamlObjectReader (instance);
1271                         while (!r.IsEof)
1272                                 r.Read ();
1273                 }
1274
1275                 void Read_CommonXamlPrimitive (object obj)
1276                 {
1277                         var r = new XamlObjectReader (obj);
1278                         Read_CommonXamlType (r);
1279                         Read_Initialization (r, obj);
1280                 }
1281
1282                 // from StartMember of Initialization to EndMember
1283                 string Read_Initialization (XamlObjectReader r, object comparableValue)
1284                 {
1285                         Assert.IsTrue (r.Read (), "init#1");
1286                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "init#2");
1287                         Assert.IsNotNull (r.Member, "init#3");
1288                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "init#3-2");
1289                         Assert.IsTrue (r.Read (), "init#4");
1290                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "init#5");
1291                         Assert.AreEqual (typeof (string), r.Value.GetType (), "init#6");
1292                         string ret = (string) r.Value;
1293                         if (comparableValue != null)
1294                                 Assert.AreEqual (comparableValue.ToString (), r.Value, "init#6-2");
1295                         Assert.IsTrue (r.Read (), "init#7");
1296                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "init#8");
1297                         return ret;
1298                 }
1299
1300                 object [] Read_AttributedArguments_String (XamlObjectReader r, string [] argNames) // valid only for string arguments.
1301                 {
1302                         object [] ret = new object [argNames.Length];
1303
1304                         Assert.IsTrue (r.Read (), "attarg.Arguments.Start1");
1305                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.Arguments.Start2");
1306                         Assert.IsNotNull (r.Member, "attarg.Arguments.Start3");
1307                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "attarg.Arguments.Start4");
1308                         for (int i = 0; i < argNames.Length; i++) {
1309                                 string arg = argNames [i];
1310                                 Assert.IsTrue (r.Read (), "attarg.ArgStartObject1." + arg);
1311                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "attarg.ArgStartObject2." + arg);
1312                                 Assert.AreEqual (typeof (string), r.Type.UnderlyingType, "attarg.ArgStartObject3." + arg);
1313                                 Assert.IsTrue (r.Read (), "attarg.ArgStartMember1." + arg);
1314                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.ArgStartMember2." + arg);
1315                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, "attarg.ArgStartMember3." + arg); // (as the argument is string here by definition)
1316                                 Assert.IsTrue (r.Read (), "attarg.ArgValue1." + arg);
1317                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "attarg.ArgValue2." + arg);
1318                                 Assert.AreEqual (typeof (string), r.Value.GetType (), "attarg.ArgValue3." + arg);
1319                                 ret [i] = r.Value;
1320                                 Assert.IsTrue (r.Read (), "attarg.ArgEndMember1." + arg);
1321                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.ArgEndMember2." + arg);
1322                                 Assert.IsTrue (r.Read (), "attarg.ArgEndObject1." + arg);
1323                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "attarg.ArgEndObject2." + arg);
1324                         }
1325                         Assert.IsTrue (r.Read (), "attarg.Arguments.End1");
1326                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.Arguments.End2");
1327                         return ret;
1328                 }
1329
1330                 // from initial to StartObject
1331                 void Read_CommonXamlType (XamlObjectReader r)
1332                 {
1333                         Assert.IsTrue (r.Read (), "ct#1");
1334                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
1335                         Assert.IsNotNull (r.Namespace, "ct#3");
1336                         Assert.AreEqual ("x", r.Namespace.Prefix, "ct#3-2");
1337                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ct#3-3");
1338                         Assert.IsNull (r.Instance, "ct#4");
1339
1340                         Assert.IsTrue (r.Read (), "ct#5");
1341                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#6");
1342                 }
1343
1344                 // from initial to StartObject
1345                 void Read_CommonClrType (XamlObjectReader r, object obj, params KeyValuePair<string,string> [] additionalNamespaces)
1346                 {
1347                         Assert.IsTrue (r.Read (), "ct#1");
1348                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
1349                         Assert.IsNotNull (r.Namespace, "ct#3");
1350                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ct#3-2");
1351                         Assert.AreEqual ("clr-namespace:" + obj.GetType ().Namespace + ";assembly=" + obj.GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ct#3-3");
1352
1353                         foreach (var kvp in additionalNamespaces) {
1354                                 Assert.IsTrue (r.Read (), "ct#4." + kvp.Key);
1355                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#5." + kvp.Key);
1356                                 Assert.IsNotNull (r.Namespace, "ct#6." + kvp.Key);
1357                                 Assert.AreEqual (kvp.Key, r.Namespace.Prefix, "ct#6-2." + kvp.Key);
1358                                 Assert.AreEqual (kvp.Value, r.Namespace.Namespace, "ct#6-3." + kvp.Key);
1359                         }
1360
1361                         Assert.IsTrue (r.Read (), "ct#7");
1362                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#8");
1363                 }
1364         }
1365
1366         class TestClass1
1367         {
1368         }
1369
1370         public class TestClass3
1371         {
1372                 public TestClass3 Nested { get; set; }
1373         }
1374
1375         public class TestClass4
1376         {
1377                 public string Foo { get; set; }
1378                 public string Bar { get; set; }
1379         }
1380
1381         public class TestClass5
1382         {
1383                 public static string Foo { get; set; }
1384                 public string Bar { get; set; }
1385                 public string Baz { internal get; set; }
1386         }
1387
1388         public class MyExtension : MarkupExtension
1389         {
1390                 public MyExtension ()
1391                 {
1392                 }
1393
1394                 public MyExtension (Type arg1, string arg2, string arg3)
1395                 {
1396                         Foo = arg1;
1397                         Bar = arg2;
1398                         Baz = arg3;
1399                 }
1400
1401                 [ConstructorArgument ("arg1")]
1402                 public Type Foo { get; set; }
1403
1404                 [ConstructorArgument ("arg2")]
1405                 public string Bar { get; set; }
1406
1407                 [ConstructorArgument ("arg3")]
1408                 public string Baz { get; set; }
1409
1410                 public override object ProvideValue (IServiceProvider provider)
1411                 {
1412                         return "provided_value";
1413                 }
1414         }
1415
1416         [TypeConverter (typeof (StringConverter))] // This attribute is the markable difference between MyExtension and this type.
1417         public class MyExtension2 : MarkupExtension
1418         {
1419                 public MyExtension2 ()
1420                 {
1421                 }
1422
1423                 public MyExtension2 (Type arg1, string arg2)
1424                 {
1425                         Foo = arg1;
1426                         Bar = arg2;
1427                 }
1428
1429                 [ConstructorArgument ("arg1")]
1430                 public Type Foo { get; set; }
1431
1432                 [ConstructorArgument ("arg2")]
1433                 public string Bar { get; set; }
1434
1435                 public override object ProvideValue (IServiceProvider provider)
1436                 {
1437                         return "provided_value";
1438                 }
1439         }
1440
1441         [TypeConverter (typeof (StringConverter))] // same as MyExtension2 except that it is *not* MarkupExtension.
1442         public class MyExtension3
1443         {
1444                 public MyExtension3 ()
1445                 {
1446                 }
1447
1448                 // cf. According to [MS-XAML-2009] 3.2.1.11, constructors are invalid unless the type is derived from TypeExtension. So, it is likely *ignored*.
1449                 public MyExtension3 (Type arg1, string arg2)
1450                 {
1451                         Foo = arg1;
1452                         Bar = arg2;
1453                 }
1454
1455                 [ConstructorArgument ("arg1")]
1456                 public Type Foo { get; set; }
1457
1458                 [ConstructorArgument ("arg2")]
1459                 public string Bar { get; set; }
1460         }
1461
1462         [TypeConverter (typeof (DateTimeConverter))] // same as MyExtension3 except for the type converter.
1463         public class MyExtension4
1464         {
1465                 public MyExtension4 ()
1466                 {
1467                 }
1468
1469                 // cf. According to [MS-XAML-2009] 3.2.1.11, constructors are invalid unless the type is derived from TypeExtension. So, it is likely *ignored*.
1470                 public MyExtension4 (Type arg1, string arg2)
1471                 {
1472                         Foo = arg1;
1473                         Bar = arg2;
1474                 }
1475
1476                 [ConstructorArgument ("arg1")]
1477                 public Type Foo { get; set; }
1478
1479                 [ConstructorArgument ("arg2")]
1480                 public string Bar { get; set; }
1481         }
1482
1483         // no type converter, and there are only simple-type arguments == _PositionalParameters is applicable. (Unlike MyExtension7)
1484         public class MyExtension5 : MarkupExtension
1485         {
1486                 public MyExtension5 (string arg1, string arg2)
1487                 {
1488                         Foo = arg1;
1489                         Bar = arg2;
1490                 }
1491
1492                 [ConstructorArgument ("arg1")]
1493                 public string Foo { get; set; }
1494
1495                 [ConstructorArgument ("arg2")]
1496                 public string Bar { get; set; }
1497
1498                 public override object ProvideValue (IServiceProvider sp)
1499                 {
1500                         return Foo;
1501                 }
1502         }
1503
1504         // Almost the same as MyExtension5, BUT there is default constructor which XamlObjectReader prefers.
1505         public class MyExtension6 : MarkupExtension
1506         {
1507                 public MyExtension6 ()
1508                 {
1509                 }
1510
1511                 public MyExtension6 (string arg1)
1512                 {
1513                         Foo = arg1;
1514                 }
1515
1516                 [ConstructorArgument ("arg1")]
1517                 public string Foo { get; set; }
1518
1519                 public override object ProvideValue (IServiceProvider sp)
1520                 {
1521                         return Foo;
1522                 }
1523         }
1524
1525         public class PositionalParametersClass1 : MarkupExtension
1526         {
1527                 public PositionalParametersClass1 (string foo)
1528                         : this (foo, -1)
1529                 {
1530                 }
1531
1532                 public PositionalParametersClass1 (string foo, int bar)
1533                 {
1534                         Foo = foo;
1535                         Bar = bar;
1536                 }
1537
1538                 [ConstructorArgument ("foo")]
1539                 public string Foo { get; set; }
1540
1541                 [ConstructorArgument ("bar")]
1542                 public int Bar { get; set; }
1543
1544                 public override object ProvideValue (IServiceProvider sp)
1545                 {
1546                         return Foo;
1547                 }
1548         }
1549
1550         public class PositionalParametersWrapper
1551         {
1552                 public PositionalParametersClass1 Body { get; set; }
1553
1554                 public PositionalParametersWrapper ()
1555                 {
1556                 }
1557
1558                 public PositionalParametersWrapper (string foo, int bar)
1559                 {
1560                         Body = new PositionalParametersClass1 (foo, bar);
1561                 }
1562         }
1563 }