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 Skip ()
 240                 {
 241                         var r = new XamlObjectReader ("Foo");
 242                         r.Skip ();
 243                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 244                         r.Skip ();
 245                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2");
 246                         r.Skip ();
 247                         Assert.IsTrue (r.IsEof, "#3");
 248                 }
 249
 250                 [Test]
 251                 public void Skip2 ()
 252                 {
 253                         var r = new XamlObjectReader ("Foo");
 254                         r.Read (); // NamespaceDeclaration
 255                         r.Read (); // Type
 256                         r.Read (); // Member (Initialization)
 257                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#1");
 258                         r.Skip ();
 259                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#2");
 260                         r.Skip ();
 261                         Assert.IsTrue (r.IsEof, "#3");
 262                 }
 263
 264                 [Test]
 265                 [Category ("NotWorking")]
 266                 public void Read2 ()
 267                 {
 268                         var doc = new XmlDocument ();
 269                         doc.LoadXml ("<root xmlns='urn:foo'><elem attr='val' /></root>");
 270                         var r = new XamlObjectReader (doc);
 271
 272                         for (int i = 0; i < 3; i++) {
 273                                 r.Read ();
 274                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-" + i);
 275                         }
 276                         r.Read ();
 277
 278                         Assert.AreEqual (new XamlType (typeof (XmlDocument), r.SchemaContext), r.Type, "#2");
 279                         r.Read ();
 280                         var l = new List<XamlMember> ();
 281                         for (int i = 0; i < 5; i++) {
 282                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-" + i);
 283                                 l.Add (r.Member);
 284                                 r.Skip ();
 285                         }
 286                         l.First (m => m.Name == "Value");
 287                         l.First (m => m.Name == "InnerXml");
 288                         l.First (m => m.Name == "Prefix");
 289                         l.First (m => m.Name == "PreserveWhitespace");
 290                         l.First (m => m.Name == "Schemas");
 291                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#4");
 292                         Assert.IsFalse (r.Read (), "#5");
 293                 }
 294
 295                 [Test]
 296                 public void Read_NonPrimitive ()
 297                 {
 298                         var r = new XamlObjectReader (new TestClass3 ());
 299                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 300                         Assert.IsTrue (r.Read (), "#6");
 301                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
 302                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#7-2");
 303                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "#7-3");
 304
 305                         Assert.IsTrue (r.Read (), "#11");
 306                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 307                         Assert.AreEqual ("x", r.Namespace.Prefix, "#12-2");
 308                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#12-3");
 309
 310                         Assert.IsTrue (r.Read (), "#16");
 311                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#17");
 312                         var xt = new XamlType (typeof (TestClass3), r.SchemaContext);
 313                         Assert.AreEqual (xt, r.Type, "#17-2");
 314                         Assert.IsTrue (r.Instance is TestClass3, "#17-3");
 315
 316                         Assert.IsTrue (r.Read (), "#21");
 317                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#22");
 318                         Assert.AreEqual (xt.GetMember ("Nested"), r.Member, "#22-2");
 319
 320                         Assert.IsTrue (r.Read (), "#26");
 321                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#27");
 322                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#27-2");
 323                         Assert.IsNull (r.Instance, "#27-3");
 324
 325                         Assert.IsTrue (r.Read (), "#31");
 326                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#32");
 327
 328                         Assert.IsTrue (r.Read (), "#36");
 329                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#37");
 330
 331                         Assert.IsTrue (r.Read (), "#41");
 332                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#42");
 333
 334                         Assert.IsFalse (r.Read (), "#46");
 335                         Assert.IsTrue (r.IsEof, "#47");
 336                 }
 337
 338                 [Test]
 339                 public void Read_Type ()
 340                 {
 341                         var r = new XamlObjectReader (typeof (int));
 342                         Read_TypeOrTypeExtension (r, typeof (int));
 343                 }
 344
 345                 [Test]
 346                 public void Read_TypeExtension ()
 347                 {
 348                         var tx = new TypeExtension (typeof (int));
 349                         var r = new XamlObjectReader (tx);
 350                         Read_TypeOrTypeExtension (r, tx);
 351                 }
 352
 353                 void Read_TypeOrTypeExtension (XamlObjectReader r, object obj)
 354                 {
 355                         Assert.IsTrue (r.Read (), "#11");
 356                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 357                         Assert.IsNotNull (r.Namespace, "#13");
 358                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 359                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 360                         Assert.IsNull (r.Instance, "#14");
 361
 362                         Assert.IsTrue (r.Read (), "#21");
 363                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 364                         Assert.IsNotNull (r.Type, "#23");
 365                         Assert.AreEqual (new XamlType (typeof (TypeExtension), r.SchemaContext), r.Type, "#23-2");
 366                         Assert.IsNull (r.Namespace, "#25");
 367                         Assert.IsTrue (r.Instance is TypeExtension, "#26");
 368
 369                         Assert.IsTrue (r.Read (), "#31");
 370                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 371                         Assert.IsNotNull (r.Member, "#33");
 372                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 373                         Assert.IsNull (r.Type, "#34");
 374                         Assert.IsNull (r.Instance, "#35");
 375
 376                         Assert.IsTrue (r.Read (), "#41");
 377                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 378                         Assert.IsNotNull (r.Value, "#43");
 379                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 380                         Assert.IsNull (r.Member, "#44");
 381                         Assert.IsNull (r.Instance, "#45");
 382
 383                         Assert.IsTrue (r.Read (), "#51");
 384                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 385                         Assert.IsNull (r.Type, "#53");
 386                         Assert.IsNull (r.Member, "#54");
 387                         Assert.IsNull (r.Instance, "#55");
 388
 389                         Assert.IsTrue (r.Read (), "#61");
 390                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 391                         Assert.IsNull (r.Type, "#63");
 392
 393                         Assert.IsFalse (r.Read (), "#71");
 394                         Assert.IsTrue (r.IsEof, "#72");
 395                 }
 396
 397                 [Test]
 398                 public void Read_Type2 ()
 399                 {
 400                         var r = new XamlObjectReader (typeof (TestClass1));
 401                         Read_TypeOrTypeExtension2 (r);
 402                 }
 403
 404                 [Test]
 405                 public void Read_TypeExtension2 ()
 406                 {
 407                         var r = new XamlObjectReader (new TypeExtension (typeof (TestClass1)));
 408                         Read_TypeOrTypeExtension2 (r);
 409                 }
 410
 411                 void Read_TypeOrTypeExtension2 (XamlObjectReader r)
 412                 {
 413                         Assert.IsTrue (r.Read (), "#11");
 414                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 415
 416                         var defns = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name;
 417
 418                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#13-2");
 419                         Assert.AreEqual (defns, r.Namespace.Namespace, "#13-3:" + r.Namespace.Prefix);
 420
 421                         Assert.IsTrue (r.Read (), "#16");
 422                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#17");
 423                         Assert.IsNotNull (r.Namespace, "#18");
 424                         Assert.AreEqual ("x", r.Namespace.Prefix, "#18-2");
 425                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#18-3:" + r.Namespace.Prefix);
 426
 427                         Assert.IsTrue (r.Read (), "#21");
 428                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 429                         Assert.AreEqual (new XamlType (typeof (TypeExtension), r.SchemaContext), r.Type, "#23-2");
 430                         Assert.IsTrue (r.Instance is TypeExtension, "#26");
 431
 432                         Assert.IsTrue (r.Read (), "#31");
 433                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 434                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 435
 436                         Assert.IsTrue (r.Read (), "#41");
 437                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 438                         Assert.AreEqual ("TestClass1", r.Value, "#43-2");
 439
 440                         Assert.IsTrue (r.Read (), "#51");
 441                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 442
 443                         Assert.IsTrue (r.Read (), "#61");
 444                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 445
 446                         Assert.IsFalse (r.Read (), "#71");
 447                         Assert.IsTrue (r.IsEof, "#72");
 448                 }
 449
 450                 [Test]
 451                 public void Read_Reference ()
 452                 {
 453                         var r = new XamlObjectReader (new Reference ("TestName"));
 454                         Assert.IsTrue (r.Read (), "#11");
 455                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 456                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 457                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 458
 459                         Assert.IsTrue (r.Read (), "#21");
 460                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 461                         var xt = new XamlType (typeof (Reference), r.SchemaContext);
 462                         Assert.AreEqual (xt, r.Type, "#23-2");
 463                         Assert.IsTrue (r.Instance is Reference, "#26");
 464
 465                         Assert.IsTrue (r.Read (), "#31");
 466                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 467                         // unlike TypeExtension there is no PositionalParameters.
 468                         Assert.AreEqual (xt.GetMember ("Name"), r.Member, "#33-2");
 469
 470                         // It is a ContentProperty (besides [ConstructorArgument])
 471                         Assert.IsTrue (r.Read (), "#41");
 472                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 473                         Assert.AreEqual ("TestName", r.Value, "#43-2");
 474
 475                         Assert.IsTrue (r.Read (), "#51");
 476                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 477
 478                         Assert.IsTrue (r.Read (), "#61");
 479                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 480
 481                         Assert.IsFalse (r.Read (), "#71");
 482                         Assert.IsTrue (r.IsEof, "#72");
 483                 }
 484
 485
 486                 [Test]
 487                 public void Read_Null ()
 488                 {
 489                         var r = new XamlObjectReader (null);
 490                         Read_NullOrNullExtension (r, null);
 491                 }
 492
 493                 [Test]
 494                 public void Read_NullExtension ()
 495                 {
 496                         var o = new NullExtension ();
 497                         var r = new XamlObjectReader (o);
 498                         Read_NullOrNullExtension (r, o);
 499                 }
 500
 501                 void Read_NullOrNullExtension (XamlObjectReader r, object instance)
 502                 {
 503                         Assert.IsTrue (r.Read (), "#11");
 504                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 505                         Assert.IsNotNull (r.Namespace, "#13");
 506                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 507                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 508                         Assert.IsNull (r.Instance, "#14");
 509
 510                         Assert.IsTrue (r.Read (), "#21");
 511                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 512                         Assert.AreEqual (new XamlType (typeof (NullExtension), r.SchemaContext), r.Type, "#23-2");
 513                         Assert.AreEqual (instance, r.Instance, "#26"); // null and NullExtension are different here.
 514
 515                         Assert.IsTrue (r.Read (), "#61");
 516                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 517
 518                         Assert.IsFalse (r.Read (), "#71");
 519                         Assert.IsTrue (r.IsEof, "#72");
 520                 }
 521
 522                 [Test] // almost identical to TypeExtension (only type/instance difference)
 523                 [Category ("NotWorking")]
 524                 public void Read_StaticExtension ()
 525                 {
 526                         var r = new XamlObjectReader (new StaticExtension ("MyMember"));
 527                         Assert.IsTrue (r.Read (), "#11");
 528                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 529                         Assert.IsNotNull (r.Namespace, "#13");
 530                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 531                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 532                         Assert.IsNull (r.Instance, "#14");
 533
 534                         Assert.IsTrue (r.Read (), "#21");
 535                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 536                         Assert.AreEqual (new XamlType (typeof (StaticExtension), r.SchemaContext), r.Type, "#23-2");
 537                         Assert.IsTrue (r.Instance is StaticExtension, "#26");
 538
 539                         Assert.IsTrue (r.Read (), "#31");
 540                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 541                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 542
 543                         Assert.IsTrue (r.Read (), "#41");
 544                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 545                         Assert.AreEqual ("MyMember", r.Value, "#43-2");
 546
 547                         Assert.IsTrue (r.Read (), "#51");
 548                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 549
 550                         Assert.IsTrue (r.Read (), "#61");
 551                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 552
 553                         Assert.IsFalse (r.Read (), "#71");
 554                         Assert.IsTrue (r.IsEof, "#72");
 555                 }
 556
 557                 [Test]
 558                 public void Read_Array ()
 559                 {
 560                         var obj = new int [] {5, -3, 0};
 561                         var r = new XamlObjectReader (obj);
 562                         Read_ArrayOrArrayExtension (r, obj);
 563                 }
 564
 565                 [Test]
 566                 public void Read_ArrayExtension ()
 567                 {
 568                         var obj = new ArrayExtension (new int [] {5, -3, 0});
 569                         var r = new XamlObjectReader (obj);
 570                         Read_ArrayOrArrayExtension (r, obj);
 571                 }
 572
 573                 void Read_ArrayOrArrayExtension (XamlObjectReader r, object instance)
 574                 {
 575                         Assert.IsTrue (r.Read (), "#11");
 576                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 577                         Assert.IsNotNull (r.Namespace, "#13");
 578                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 579                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 580
 581                         Assert.IsTrue (r.Read (), "#21");
 582                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 583                         var xt = new XamlType (typeof (ArrayExtension), r.SchemaContext);
 584                         Assert.AreEqual (xt, r.Type, "#23");
 585                         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)
 586
 587                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 588
 589                         Assert.IsTrue (r.Read (), "#31");
 590                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 591                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33");
 592
 593                         Assert.IsTrue (r.Read (), "#41");
 594                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 595                         Assert.AreEqual ("x:Int32", r.Value, "#43");
 596
 597                         Assert.IsTrue (r.Read (), "#51");
 598                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 599
 600                         Assert.IsTrue (r.Read (), "#61");
 601                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
 602                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
 603
 604                         Assert.IsTrue (r.Read (), "#71");
 605                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
 606                         Assert.IsNull (r.Type, "#71-3");
 607                         Assert.IsNull (r.Member, "#71-4");
 608                         Assert.IsNull (r.Value, "#71-5");
 609
 610                         Assert.IsTrue (r.Read (), "#72");
 611                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 612                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 613
 614                         string [] values = {"5", "-3", "0"};
 615                         for (int i = 0; i < 3; i++) {
 616                                 Assert.IsTrue (r.Read (), i + "#73");
 617                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 618                                 Assert.IsTrue (r.Read (), i + "#74");
 619                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 620                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 621                                 Assert.IsTrue (r.Read (), i + "#75");
 622                                 Assert.IsNotNull (r.Value, i + "#75-2");
 623                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 624                                 Assert.IsTrue (r.Read (), i + "#74");
 625                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 626                                 Assert.IsTrue (r.Read (), i + "#75");
 627                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 628                         }
 629
 630                         Assert.IsTrue (r.Read (), "#81");
 631                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 632
 633                         Assert.IsTrue (r.Read (), "#83");
 634                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
 635
 636                         Assert.IsTrue (r.Read (), "#85");
 637                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ArrayExtension.Items
 638
 639                         Assert.IsTrue (r.Read (), "#87");
 640                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ArrayExtension
 641
 642                         Assert.IsFalse (r.Read (), "#89");
 643                 }
 644
 645                 [Test] // It gives Type member, not PositionalParameters... and no Items member here.
 646                 public void Read_ArrayExtension2 ()
 647                 {
 648                         var r = new XamlObjectReader (new ArrayExtension (typeof (int)));
 649                         Assert.IsTrue (r.Read (), "#11");
 650                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 651                         Assert.IsNotNull (r.Namespace, "#13");
 652                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 653                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 654                         Assert.IsNull (r.Instance, "#14");
 655
 656                         Assert.IsTrue (r.Read (), "#21");
 657                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 658                         var xt = new XamlType (typeof (ArrayExtension), r.SchemaContext);
 659                         Assert.AreEqual (xt, r.Type, "#23-2");
 660                         Assert.IsTrue (r.Instance is ArrayExtension, "#26");
 661
 662                         Assert.IsTrue (r.Read (), "#31");
 663                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 664                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33-2");
 665
 666                         Assert.IsTrue (r.Read (), "#41");
 667                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 668                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 669
 670                         Assert.IsTrue (r.Read (), "#51");
 671                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 672
 673                         Assert.IsTrue (r.Read (), "#61");
 674                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 675
 676                         Assert.IsFalse (r.Read (), "#71");
 677                         Assert.IsTrue (r.IsEof, "#72");
 678                 }
 679
 680                 [Test]
 681                 public void Read_DateTime ()
 682                 {
 683                         var obj = new DateTime (2010, 4, 15);
 684                         var r = new XamlObjectReader (obj);
 685                         Read_CommonClrType (r, obj);
 686                         Assert.AreEqual ("2010-04-15", Read_Initialization (r, null), "#1");
 687                 }
 688
 689                 [Test]
 690                 public void Read_TimeSpan ()
 691                 {
 692                         Read_CommonXamlPrimitive (TimeSpan.FromMinutes (4));
 693                 }
 694
 695                 [Test]
 696                 public void Read_Uri ()
 697                 {
 698                         Read_CommonXamlPrimitive (new Uri ("urn:foo"));
 699                 }
 700
 701                 [Test]
 702                 [ExpectedException (typeof (XamlObjectReaderException))]
 703                 [Category ("NotWorking")]
 704                 public void Read_XData ()
 705                 {
 706                         var r = new XamlObjectReader (new XData () {Text = "xdata text"}); // XmlReader implementation is not visible.
 707                         while (!r.IsEof)
 708                                 r.Read ();
 709                 }
 710
 711                 [Test]
 712                 public void ReadStandardTypes ()
 713                 {
 714                         SimpleReadStandardType (new ArrayExtension ());
 715                         SimpleReadStandardType (new NullExtension ());
 716                         SimpleReadStandardType (new PropertyDefinition ());
 717                         SimpleReadStandardType (new Reference ());
 718                         SimpleReadStandardType (new StaticExtension ());
 719                         SimpleReadStandardType (new TypeExtension ());
 720                 }
 721
 722                 [Test]
 723                 public void Read_CustomMarkupExtension ()
 724                 {
 725                         var r = new XamlObjectReader (new MyExtension () { Foo = typeof (int), Bar = "v2", Baz = "v7"});
 726                         r.Read (); // ns
 727                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 728                         r.Read (); // ns
 729                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-2");
 730                         r.Read ();
 731                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
 732                         Assert.IsFalse (r.IsEof, "#1");
 733                         var xt = r.Type;
 734
 735                         r.Read ();
 736                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#2-1");
 737                         Assert.IsFalse (r.IsEof, "#2-2");
 738                         Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#2-3");
 739
 740                         Assert.IsTrue (r.Read (), "#2-4");
 741                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#2-5");
 742                         Assert.AreEqual ("v2", r.Value, "#2-6");
 743
 744                         Assert.IsTrue (r.Read (), "#2-7");
 745                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#2-8");
 746
 747                         r.Read ();
 748                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-1");
 749                         Assert.IsFalse (r.IsEof, "#3-2");
 750                         Assert.AreEqual (xt.GetMember ("Baz"), r.Member, "#3-3");
 751
 752                         Assert.IsTrue (r.Read (), "#3-4");
 753                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#3-5");
 754                         Assert.AreEqual ("v7", r.Value, "#3-6");
 755
 756                         Assert.IsTrue (r.Read (), "#3-7");
 757                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#3-8");
 758
 759                         r.Read ();
 760                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#4-1");
 761                         Assert.IsFalse (r.IsEof, "#4-2");
 762                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4-3");
 763                         Assert.IsTrue (r.Read (), "#4-4");
 764                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#4-5");
 765                         Assert.AreEqual ("x:Int32", r.Value, "#4-6");
 766
 767                         Assert.IsTrue (r.Read (), "#4-7");
 768                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#4-8");
 769
 770                         Assert.IsTrue (r.Read (), "#5");
 771                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#5-2");
 772
 773                         Assert.IsFalse (r.Read (), "#6");
 774                 }
 775
 776                 [Test]
 777                 public void Read_CustomMarkupExtension2 ()
 778                 {
 779                         var r = new XamlObjectReader (new MyExtension2 () { Foo = typeof (int), Bar = "v2"});
 780                         r.Read (); // ns
 781                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 782                         r.Read (); // note that there wasn't another NamespaceDeclaration.
 783                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
 784                         var xt = r.Type;
 785                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension2)), xt, "#2");
 786                         Assert.IsTrue (r.Read (), "#3");
 787                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
 788                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
 789                         Assert.IsTrue (r.Read (), "#5");
 790                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension2", r.Value, "#6");
 791                         Assert.IsTrue (r.Read (), "#7"); // EndMember
 792                         Assert.IsTrue (r.Read (), "#8"); // EndObject
 793                         Assert.IsFalse (r.Read (), "#9");
 794                 }
 795
 796                 [Test]
 797                 public void Read_CustomMarkupExtension3 ()
 798                 {
 799                         var r = new XamlObjectReader (new MyExtension3 () { Foo = typeof (int), Bar = "v2"});
 800                         r.Read (); // ns
 801                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 802                         r.Read (); // note that there wasn't another NamespaceDeclaration.
 803                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
 804                         var xt = r.Type;
 805                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension3)), xt, "#2");
 806                         Assert.IsTrue (r.Read (), "#3");
 807                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
 808                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
 809                         Assert.IsTrue (r.Read (), "#5");
 810                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension3", r.Value, "#6");
 811                         Assert.IsTrue (r.Read (), "#7"); // EndMember
 812                         Assert.IsTrue (r.Read (), "#8"); // EndObject
 813                         Assert.IsFalse (r.Read (), "#9");
 814                 }
 815
 816                 [Test]
 817                 public void Read_CustomMarkupExtension4 ()
 818                 {
 819                         var r = new XamlObjectReader (new MyExtension4 () { Foo = typeof (int), Bar = "v2"});
 820                         r.Read (); // ns
 821                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 822                         r.Read (); // note that there wasn't another NamespaceDeclaration.
 823                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
 824                         var xt = r.Type;
 825                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension4)), xt, "#2");
 826                         Assert.IsTrue (r.Read (), "#3");
 827                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
 828                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
 829                         Assert.IsTrue (r.Read (), "#5");
 830                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension4", r.Value, "#6");
 831                         Assert.IsTrue (r.Read (), "#7"); // EndMember
 832                         Assert.IsTrue (r.Read (), "#8"); // EndObject
 833                         Assert.IsFalse (r.Read (), "#9");
 834                 }
 835
 836                 [Test]
 837                 public void Read_ArgumentAttributed ()
 838                 {
 839                         var obj = new ArgumentAttributed ("foo", "bar");
 840                         var r = new XamlObjectReader (obj);
 841                         Read_CommonClrType (r, obj, new KeyValuePair<string,string> ("x", XamlLanguage.Xaml2006Namespace));
 842                         var args = Read_AttributedArguments_String (r, new string [] {"arg1", "arg2"});
 843                         Assert.AreEqual ("foo", args [0], "#1");
 844                         Assert.AreEqual ("bar", args [1], "#2");
 845                 }
 846
 847                 void SimpleReadStandardType (object instance)
 848                 {
 849                         var r = new XamlObjectReader (instance);
 850                         while (!r.IsEof)
 851                                 r.Read ();
 852                 }
 853
 854                 void Read_CommonXamlPrimitive (object obj)
 855                 {
 856                         var r = new XamlObjectReader (obj);
 857                         Read_CommonXamlType (r);
 858                         Read_Initialization (r, obj);
 859                 }
 860
 861                 // from StartMember of Initialization to EndMember
 862                 string Read_Initialization (XamlObjectReader r, object comparableValue)
 863                 {
 864                         Assert.IsTrue (r.Read (), "init#1");
 865                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "init#2");
 866                         Assert.IsNotNull (r.Member, "init#3");
 867                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "init#3-2");
 868                         Assert.IsTrue (r.Read (), "init#4");
 869                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "init#5");
 870                         Assert.AreEqual (typeof (string), r.Value.GetType (), "init#6");
 871                         string ret = (string) r.Value;
 872                         if (comparableValue != null)
 873                                 Assert.AreEqual (comparableValue.ToString (), r.Value, "init#6-2");
 874                         Assert.IsTrue (r.Read (), "init#7");
 875                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "init#8");
 876                         return ret;
 877                 }
 878
 879                 object [] Read_AttributedArguments_String (XamlObjectReader r, string [] argNames) // valid only for string arguments.
 880                 {
 881                         object [] ret = new object [argNames.Length];
 882
 883                         Assert.IsTrue (r.Read (), "attarg.Arguments.Start1");
 884                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.Arguments.Start2");
 885                         Assert.IsNotNull (r.Member, "attarg.Arguments.Start3");
 886                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "attarg.Arguments.Start4");
 887                         for (int i = 0; i < argNames.Length; i++) {
 888                                 string arg = argNames [i];
 889                                 Assert.IsTrue (r.Read (), "attarg.ArgStartObject1." + arg);
 890                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "attarg.ArgStartObject2." + arg);
 891                                 Assert.AreEqual (typeof (string), r.Type.UnderlyingType, "attarg.ArgStartObject3." + arg);
 892                                 Assert.IsTrue (r.Read (), "attarg.ArgStartMember1." + arg);
 893                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.ArgStartMember2." + arg);
 894                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, "attarg.ArgStartMember3." + arg); // (as the argument is string here by definition)
 895                                 Assert.IsTrue (r.Read (), "attarg.ArgValue1." + arg);
 896                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "attarg.ArgValue2." + arg);
 897                                 Assert.AreEqual (typeof (string), r.Value.GetType (), "attarg.ArgValue3." + arg);
 898                                 ret [i] = r.Value;
 899                                 Assert.IsTrue (r.Read (), "attarg.ArgEndMember1." + arg);
 900                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.ArgEndMember2." + arg);
 901                                 Assert.IsTrue (r.Read (), "attarg.ArgEndObject1." + arg);
 902                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "attarg.ArgEndObject2." + arg);
 903                         }
 904                         Assert.IsTrue (r.Read (), "attarg.Arguments.End1");
 905                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.Arguments.End2");
 906                         return ret;
 907                 }
 908
 909                 // from initial to StartObject
 910                 void Read_CommonXamlType (XamlObjectReader r)
 911                 {
 912                         Assert.IsTrue (r.Read (), "ct#1");
 913                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
 914                         Assert.IsNotNull (r.Namespace, "ct#3");
 915                         Assert.AreEqual ("x", r.Namespace.Prefix, "ct#3-2");
 916                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ct#3-3");
 917                         Assert.IsNull (r.Instance, "ct#4");
 918
 919                         Assert.IsTrue (r.Read (), "ct#5");
 920                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#6");
 921                 }
 922
 923                 // from initial to StartObject
 924                 void Read_CommonClrType (XamlObjectReader r, object obj, params KeyValuePair<string,string> [] additionalNamespaces)
 925                 {
 926                         Assert.IsTrue (r.Read (), "ct#1");
 927                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
 928                         Assert.IsNotNull (r.Namespace, "ct#3");
 929                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ct#3-2");
 930                         Assert.AreEqual ("clr-namespace:" + obj.GetType ().Namespace + ";assembly=" + obj.GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ct#3-3");
 931
 932                         foreach (var kvp in additionalNamespaces) {
 933                                 Assert.IsTrue (r.Read (), "ct#4." + kvp.Key);
 934                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#5." + kvp.Key);
 935                                 Assert.IsNotNull (r.Namespace, "ct#6." + kvp.Key);
 936                                 Assert.AreEqual (kvp.Key, r.Namespace.Prefix, "ct#6-2." + kvp.Key);
 937                                 Assert.AreEqual (kvp.Value, r.Namespace.Namespace, "ct#6-3." + kvp.Key);
 938                         }
 939
 940                         Assert.IsTrue (r.Read (), "ct#7");
 941                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#8");
 942                 }
 943         }
 944
 945         class TestClass1
 946         {
 947         }
 948
 949         public class TestClass3
 950         {
 951                 public TestClass3 Nested { get; set; }
 952         }
 953
 954         public class TestClass4
 955         {
 956                 public string Foo { get; set; }
 957                 public string Bar { get; set; }
 958         }
 959
 960         public class MyExtension : MarkupExtension
 961         {
 962                 public MyExtension ()
 963                 {
 964                 }
 965
 966                 public MyExtension (Type arg1, string arg2, string arg3)
 967                 {
 968                         Foo = arg1;
 969                         Bar = arg2;
 970                         Baz = arg3;
 971                 }
 972
 973                 [ConstructorArgument ("arg1")]
 974                 public Type Foo { get; set; }
 975
 976                 [ConstructorArgument ("arg2")]
 977                 public string Bar { get; set; }
 978
 979                 [ConstructorArgument ("arg3")]
 980                 public string Baz { get; set; }
 981
 982                 public override object ProvideValue (IServiceProvider provider)
 983                 {
 984                         return "provided_value";
 985                 }
 986         }
 987
 988         [TypeConverter (typeof (StringConverter))] // This attribute is the markable difference between MyExtension and this type.
 989         public class MyExtension2 : MarkupExtension
 990         {
 991                 public MyExtension2 ()
 992                 {
 993                 }
 994
 995                 public MyExtension2 (Type arg1, string arg2)
 996                 {
 997                         Foo = arg1;
 998                         Bar = arg2;
 999                 }
1000
1001                 [ConstructorArgument ("arg1")]
1002                 public Type Foo { get; set; }
1003
1004                 [ConstructorArgument ("arg2")]
1005                 public string Bar { get; set; }
1006
1007                 public override object ProvideValue (IServiceProvider provider)
1008                 {
1009                         return "provided_value";
1010                 }
1011         }
1012
1013         [TypeConverter (typeof (StringConverter))] // same as MyExtension2 except that it is *not* MarkupExtension.
1014         public class MyExtension3
1015         {
1016                 public MyExtension3 ()
1017                 {
1018                 }
1019
1020                 // 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*.
1021                 public MyExtension3 (Type arg1, string arg2)
1022                 {
1023                         Foo = arg1;
1024                         Bar = arg2;
1025                 }
1026
1027                 [ConstructorArgument ("arg1")]
1028                 public Type Foo { get; set; }
1029
1030                 [ConstructorArgument ("arg2")]
1031                 public string Bar { get; set; }
1032         }
1033
1034         [TypeConverter (typeof (DateTimeConverter))] // same as MyExtension3 except for the type converter.
1035         public class MyExtension4
1036         {
1037                 public MyExtension4 ()
1038                 {
1039                 }
1040
1041                 // 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*.
1042                 public MyExtension4 (Type arg1, string arg2)
1043                 {
1044                         Foo = arg1;
1045                         Bar = arg2;
1046                 }
1047
1048                 [ConstructorArgument ("arg1")]
1049                 public Type Foo { get; set; }
1050
1051                 [ConstructorArgument ("arg2")]
1052                 public string Bar { get; set; }
1053         }
1054 }