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                         // ReadOnly is not included in GetAllMembers() return value neither.
 279                         // nonpublic Baz is a member, but does not appear in the reader.
 280
 281                         Assert.IsTrue (r.Read (), "#51");
 282                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#52");
 283
 284                         Assert.IsFalse (r.Read (), "#56");
 285                         Assert.IsTrue (r.IsEof, "#57");
 286                 }
 287
 288                 [Test]
 289                 public void Skip ()
 290                 {
 291                         var r = new XamlObjectReader ("Foo");
 292                         r.Skip ();
 293                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 294                         r.Skip ();
 295                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2");
 296                         r.Skip ();
 297                         Assert.IsTrue (r.IsEof, "#3");
 298                 }
 299
 300                 [Test]
 301                 public void Skip2 ()
 302                 {
 303                         var r = new XamlObjectReader ("Foo");
 304                         r.Read (); // NamespaceDeclaration
 305                         r.Read (); // Type
 306                         r.Read (); // Member (Initialization)
 307                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#1");
 308                         r.Skip ();
 309                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#2");
 310                         r.Skip ();
 311                         Assert.IsTrue (r.IsEof, "#3");
 312                 }
 313
 314                 [Test]
 315                 public void Read2 ()
 316                 {
 317                         var doc = new XmlDocument ();
 318                         doc.LoadXml ("<root xmlns='urn:foo'><elem attr='val' /></root>");
 319                         var r = new XamlObjectReader (doc);
 320
 321                         for (int i = 0; i < 3; i++) {
 322                                 r.Read ();
 323                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-" + i);
 324                         }
 325                         r.Read ();
 326
 327                         Assert.AreEqual (new XamlType (typeof (XmlDocument), r.SchemaContext), r.Type, "#2");
 328                         r.Read ();
 329                         var l = new List<XamlMember> ();
 330                         for (int i = 0; i < 5; i++) {
 331                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-" + i);
 332                                 l.Add (r.Member);
 333                                 r.Skip ();
 334                         }
 335                         l.First (m => m.Name == "Value");
 336                         l.First (m => m.Name == "InnerXml");
 337                         l.First (m => m.Name == "Prefix");
 338                         l.First (m => m.Name == "PreserveWhitespace");
 339                         l.First (m => m.Name == "Schemas");
 340                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#4");
 341                         Assert.IsFalse (r.Read (), "#5");
 342                 }
 343
 344                 [Test]
 345                 public void Read_NonPrimitive ()
 346                 {
 347                         var r = new XamlObjectReader (new TestClass3 ());
 348                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 349                         Assert.IsTrue (r.Read (), "#6");
 350                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
 351                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#7-2");
 352                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "#7-3");
 353
 354                         Assert.IsTrue (r.Read (), "#11");
 355                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 356                         Assert.AreEqual ("x", r.Namespace.Prefix, "#12-2");
 357                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#12-3");
 358
 359                         Assert.IsTrue (r.Read (), "#16");
 360                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#17");
 361                         var xt = new XamlType (typeof (TestClass3), r.SchemaContext);
 362                         Assert.AreEqual (xt, r.Type, "#17-2");
 363                         Assert.IsTrue (r.Instance is TestClass3, "#17-3");
 364
 365                         Assert.IsTrue (r.Read (), "#21");
 366                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#22");
 367                         Assert.AreEqual (xt.GetMember ("Nested"), r.Member, "#22-2");
 368
 369                         Assert.IsTrue (r.Read (), "#26");
 370                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#27");
 371                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#27-2");
 372                         Assert.IsNull (r.Instance, "#27-3");
 373
 374                         Assert.IsTrue (r.Read (), "#31");
 375                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#32");
 376
 377                         Assert.IsTrue (r.Read (), "#36");
 378                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#37");
 379
 380                         Assert.IsTrue (r.Read (), "#41");
 381                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#42");
 382
 383                         Assert.IsFalse (r.Read (), "#46");
 384                         Assert.IsTrue (r.IsEof, "#47");
 385                 }
 386
 387                 [Test]
 388                 public void Read_Type ()
 389                 {
 390                         var r = new XamlObjectReader (typeof (int));
 391                         Read_TypeOrTypeExtension (r, typeof (int));
 392                 }
 393
 394                 [Test]
 395                 public void Read_TypeExtension ()
 396                 {
 397                         var tx = new TypeExtension (typeof (int));
 398                         var r = new XamlObjectReader (tx);
 399                         Read_TypeOrTypeExtension (r, tx);
 400                 }
 401
 402                 void Read_TypeOrTypeExtension (XamlObjectReader r, object obj)
 403                 {
 404                         Assert.IsTrue (r.Read (), "#11");
 405                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 406                         Assert.IsNotNull (r.Namespace, "#13");
 407                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 408                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 409                         Assert.IsNull (r.Instance, "#14");
 410
 411                         Assert.IsTrue (r.Read (), "#21");
 412                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 413                         Assert.IsNotNull (r.Type, "#23");
 414                         Assert.AreEqual (new XamlType (typeof (TypeExtension), r.SchemaContext), r.Type, "#23-2");
 415                         Assert.IsNull (r.Namespace, "#25");
 416                         Assert.IsTrue (r.Instance is TypeExtension, "#26");
 417
 418                         Assert.IsTrue (r.Read (), "#31");
 419                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 420                         Assert.IsNotNull (r.Member, "#33");
 421                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 422                         Assert.IsNull (r.Type, "#34");
 423                         Assert.IsNull (r.Instance, "#35");
 424
 425                         Assert.IsTrue (r.Read (), "#41");
 426                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 427                         Assert.IsNotNull (r.Value, "#43");
 428                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 429                         Assert.IsNull (r.Member, "#44");
 430                         Assert.IsNull (r.Instance, "#45");
 431
 432                         Assert.IsTrue (r.Read (), "#51");
 433                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 434                         Assert.IsNull (r.Type, "#53");
 435                         Assert.IsNull (r.Member, "#54");
 436                         Assert.IsNull (r.Instance, "#55");
 437
 438                         Assert.IsTrue (r.Read (), "#61");
 439                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 440                         Assert.IsNull (r.Type, "#63");
 441
 442                         Assert.IsFalse (r.Read (), "#71");
 443                         Assert.IsTrue (r.IsEof, "#72");
 444                 }
 445
 446                 [Test]
 447                 public void Read_Type2 ()
 448                 {
 449                         var r = new XamlObjectReader (typeof (TestClass1));
 450                         Read_TypeOrTypeExtension2 (r);
 451                 }
 452
 453                 [Test]
 454                 public void Read_TypeExtension2 ()
 455                 {
 456                         var r = new XamlObjectReader (new TypeExtension (typeof (TestClass1)));
 457                         Read_TypeOrTypeExtension2 (r);
 458                 }
 459
 460                 void Read_TypeOrTypeExtension2 (XamlObjectReader r)
 461                 {
 462                         Assert.IsTrue (r.Read (), "#11");
 463                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 464
 465                         var defns = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name;
 466
 467                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#13-2");
 468                         Assert.AreEqual (defns, r.Namespace.Namespace, "#13-3:" + r.Namespace.Prefix);
 469
 470                         Assert.IsTrue (r.Read (), "#16");
 471                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#17");
 472                         Assert.IsNotNull (r.Namespace, "#18");
 473                         Assert.AreEqual ("x", r.Namespace.Prefix, "#18-2");
 474                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#18-3:" + r.Namespace.Prefix);
 475
 476                         Assert.IsTrue (r.Read (), "#21");
 477                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 478                         Assert.AreEqual (new XamlType (typeof (TypeExtension), r.SchemaContext), r.Type, "#23-2");
 479                         Assert.IsTrue (r.Instance is TypeExtension, "#26");
 480
 481                         Assert.IsTrue (r.Read (), "#31");
 482                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 483                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 484
 485                         Assert.IsTrue (r.Read (), "#41");
 486                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 487                         Assert.AreEqual ("TestClass1", r.Value, "#43-2");
 488
 489                         Assert.IsTrue (r.Read (), "#51");
 490                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 491
 492                         Assert.IsTrue (r.Read (), "#61");
 493                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 494
 495                         Assert.IsFalse (r.Read (), "#71");
 496                         Assert.IsTrue (r.IsEof, "#72");
 497                 }
 498
 499                 [Test]
 500                 public void Read_Reference ()
 501                 {
 502                         var r = new XamlObjectReader (new Reference ("TestName"));
 503                         Assert.IsTrue (r.Read (), "#11");
 504                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 505                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 506                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 507
 508                         Assert.IsTrue (r.Read (), "#21");
 509                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 510                         var xt = new XamlType (typeof (Reference), r.SchemaContext);
 511                         Assert.AreEqual (xt, r.Type, "#23-2");
 512                         Assert.IsTrue (r.Instance is Reference, "#26");
 513
 514                         Assert.IsTrue (r.Read (), "#31");
 515                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 516                         // unlike TypeExtension there is no PositionalParameters.
 517                         Assert.AreEqual (xt.GetMember ("Name"), r.Member, "#33-2");
 518
 519                         // It is a ContentProperty (besides [ConstructorArgument])
 520                         Assert.IsTrue (r.Read (), "#41");
 521                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 522                         Assert.AreEqual ("TestName", r.Value, "#43-2");
 523
 524                         Assert.IsTrue (r.Read (), "#51");
 525                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 526
 527                         Assert.IsTrue (r.Read (), "#61");
 528                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 529
 530                         Assert.IsFalse (r.Read (), "#71");
 531                         Assert.IsTrue (r.IsEof, "#72");
 532                 }
 533
 534
 535                 [Test]
 536                 public void Read_Null ()
 537                 {
 538                         var r = new XamlObjectReader (null);
 539                         Read_NullOrNullExtension (r, null);
 540                 }
 541
 542                 [Test]
 543                 public void Read_NullExtension ()
 544                 {
 545                         var o = new NullExtension ();
 546                         var r = new XamlObjectReader (o);
 547                         Read_NullOrNullExtension (r, o);
 548                 }
 549
 550                 void Read_NullOrNullExtension (XamlObjectReader r, object instance)
 551                 {
 552                         Assert.IsTrue (r.Read (), "#11");
 553                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 554                         Assert.IsNotNull (r.Namespace, "#13");
 555                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 556                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 557                         Assert.IsNull (r.Instance, "#14");
 558
 559                         Assert.IsTrue (r.Read (), "#21");
 560                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 561                         Assert.AreEqual (new XamlType (typeof (NullExtension), r.SchemaContext), r.Type, "#23-2");
 562                         Assert.AreEqual (instance, r.Instance, "#26"); // null and NullExtension are different here.
 563
 564                         Assert.IsTrue (r.Read (), "#61");
 565                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 566
 567                         Assert.IsFalse (r.Read (), "#71");
 568                         Assert.IsTrue (r.IsEof, "#72");
 569                 }
 570
 571                 [Test] // almost identical to TypeExtension (only type/instance difference)
 572                 public void Read_StaticExtension ()
 573                 {
 574                         var r = new XamlObjectReader (new StaticExtension ("MyMember"));
 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                         Assert.IsNull (r.Instance, "#14");
 581
 582                         Assert.IsTrue (r.Read (), "#21");
 583                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 584                         Assert.AreEqual (new XamlType (typeof (StaticExtension), r.SchemaContext), r.Type, "#23-2");
 585                         Assert.IsTrue (r.Instance is StaticExtension, "#26");
 586
 587                         Assert.IsTrue (r.Read (), "#31");
 588                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 589                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 590
 591                         Assert.IsTrue (r.Read (), "#41");
 592                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 593                         Assert.AreEqual ("MyMember", r.Value, "#43-2");
 594
 595                         Assert.IsTrue (r.Read (), "#51");
 596                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 597
 598                         Assert.IsTrue (r.Read (), "#61");
 599                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 600
 601                         Assert.IsFalse (r.Read (), "#71");
 602                         Assert.IsTrue (r.IsEof, "#72");
 603                 }
 604
 605                 [Test]
 606                 public void Read_ListInt32 ()
 607                 {
 608                         var obj = new List<int> (new int [] {5, -3, 0});
 609                         Read_ListInt32 (obj);
 610                 }
 611
 612                 [Test]
 613                 [Category ("NotWorking")]
 614                 public void Read_ListInt32_2 ()
 615                 {
 616                         var obj = new List<int> (new int [0]);
 617                         Read_ListInt32 (obj);
 618                 }
 619
 620                 void Read_ListInt32 (List<int> obj)
 621                 {
 622                         var r = new XamlObjectReader (obj);
 623                         Assert.IsTrue (r.Read (), "ns#1-1");
 624                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
 625
 626                         var defns = "clr-namespace:System.Collections.Generic;assembly=mscorlib";
 627
 628                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3");
 629                         Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4");
 630
 631                         Assert.IsTrue (r.Read (), "#11");
 632                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 633                         Assert.IsNotNull (r.Namespace, "#13");
 634                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 635                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 636
 637                         Assert.IsTrue (r.Read (), "#21");
 638                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 639                         var xt = new XamlType (typeof (List<int>), r.SchemaContext);
 640                         Assert.AreEqual (xt, r.Type, "#23");
 641                         Assert.AreEqual (obj, r.Instance, "#26");
 642                         Assert.IsTrue (xt.IsCollection, "#27");
 643
 644                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 645
 646                         Assert.IsTrue (r.Read (), "#31");
 647                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 648                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
 649
 650                         Assert.IsTrue (r.Read (), "#41");
 651                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 652                         // The value is implementation details, not testable.
 653                         //Assert.AreEqual ("3", r.Value, "#43");
 654
 655                         Assert.IsTrue (r.Read (), "#51");
 656                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 657
 658                         if (obj.Count > 0) { // only when items exist.
 659
 660                         Assert.IsTrue (r.Read (), "#72");
 661                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 662                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 663
 664                         string [] values = {"5", "-3", "0"};
 665                         for (int i = 0; i < 3; i++) {
 666                                 Assert.IsTrue (r.Read (), i + "#73");
 667                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 668                                 Assert.IsTrue (r.Read (), i + "#74");
 669                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 670                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 671                                 Assert.IsTrue (r.Read (), i + "#75");
 672                                 Assert.IsNotNull (r.Value, i + "#75-2");
 673                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 674                                 Assert.IsTrue (r.Read (), i + "#74");
 675                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 676                                 Assert.IsTrue (r.Read (), i + "#75");
 677                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 678                         }
 679
 680                         Assert.IsTrue (r.Read (), "#81");
 681                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 682
 683                         } // end of "if count > 0".
 684
 685                         Assert.IsTrue (r.Read (), "#87");
 686                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88");
 687
 688                         Assert.IsFalse (r.Read (), "#89");
 689                 }
 690
 691                 [Test]
 692                 public void Read_ArrayList ()
 693                 {
 694                         var obj = new ArrayList (new int [] {5, -3, 0});
 695
 696                         var r = new XamlObjectReader (obj);
 697                         Assert.IsTrue (r.Read (), "ns#1-1");
 698                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
 699
 700                         var defns = "clr-namespace:System.Collections;assembly=mscorlib";
 701
 702                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3");
 703                         Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4");
 704
 705                         Assert.IsTrue (r.Read (), "#11");
 706                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 707                         Assert.IsNotNull (r.Namespace, "#13");
 708                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 709                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 710
 711                         Assert.IsTrue (r.Read (), "#21");
 712                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 713                         var xt = new XamlType (typeof (ArrayList), r.SchemaContext);
 714                         Assert.AreEqual (xt, r.Type, "#23");
 715                         Assert.AreEqual (obj, r.Instance, "#26");
 716                         Assert.IsTrue (xt.IsCollection, "#27");
 717
 718                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 719
 720                         Assert.IsTrue (r.Read (), "#31");
 721                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 722                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
 723
 724                         Assert.IsTrue (r.Read (), "#41");
 725                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 726                         // The value is implementation details, not testable.
 727                         //Assert.AreEqual ("3", r.Value, "#43");
 728
 729                         Assert.IsTrue (r.Read (), "#51");
 730                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 731
 732                         Assert.IsTrue (r.Read (), "#72");
 733                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 734                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 735
 736                         string [] values = {"5", "-3", "0"};
 737                         for (int i = 0; i < 3; i++) {
 738                                 Assert.IsTrue (r.Read (), i + "#73");
 739                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 740                                 Assert.IsTrue (r.Read (), i + "#74");
 741                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 742                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 743                                 Assert.IsTrue (r.Read (), i + "#75");
 744                                 Assert.IsNotNull (r.Value, i + "#75-2");
 745                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 746                                 Assert.IsTrue (r.Read (), i + "#74");
 747                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 748                                 Assert.IsTrue (r.Read (), i + "#75");
 749                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 750                         }
 751
 752                         Assert.IsTrue (r.Read (), "#81");
 753                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 754
 755                         Assert.IsTrue (r.Read (), "#87");
 756                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88");
 757
 758                         Assert.IsFalse (r.Read (), "#89");
 759                 }
 760
 761                 [Test]
 762                 public void Read_Array ()
 763                 {
 764                         var obj = new int [] {5, -3, 0};
 765                         var r = new XamlObjectReader (obj);
 766                         Read_ArrayOrArrayExtension (r, obj);
 767                 }
 768
 769                 [Test]
 770                 public void Read_ArrayExtension ()
 771                 {
 772                         var obj = new ArrayExtension (new int [] {5, -3, 0});
 773                         var r = new XamlObjectReader (obj);
 774                         Read_ArrayOrArrayExtension (r, obj);
 775                 }
 776
 777                 [Test]
 778                 [Category ("NotWorking")]
 779                 public void Read_MyArrayExtension ()
 780                 {
 781                         var obj = new MyArrayExtension (new int [] {5, -3, 0});
 782                         var r = new XamlObjectReader (obj);
 783                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, obj, typeof (MyArrayExtension));
 784                 }
 785
 786                 void Read_ArrayOrArrayExtension (XamlObjectReader r, object instance)
 787                 {
 788                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, instance, typeof (ArrayExtension));
 789                 }
 790
 791                 void Read_ArrayOrArrayExtensionOrMyArrayExtension (XamlObjectReader r, object instance, Type extType)
 792                 {
 793                         if (extType == typeof (MyArrayExtension)) {
 794                                 Assert.IsTrue (r.Read (), "#1");
 795                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
 796                                 Assert.IsNotNull (r.Namespace, "#3");
 797                                 Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
 798                         }
 799                         Assert.IsTrue (r.Read (), "#11");
 800                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 801                         Assert.IsNotNull (r.Namespace, "#13");
 802                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 803                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 804
 805                         Assert.IsTrue (r.Read (), "#21");
 806                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 807                         var xt = new XamlType (extType, r.SchemaContext);
 808                         Assert.AreEqual (xt, r.Type, "#23");
 809                         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)
 810
 811                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 812
 813                         Assert.IsTrue (r.Read (), "#31");
 814                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 815                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33");
 816
 817                         Assert.IsTrue (r.Read (), "#41");
 818                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 819                         Assert.AreEqual ("x:Int32", r.Value, "#43");
 820
 821                         Assert.IsTrue (r.Read (), "#51");
 822                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 823
 824                         Assert.IsTrue (r.Read (), "#61");
 825                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
 826                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
 827
 828                         Assert.IsTrue (r.Read (), "#71");
 829                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
 830                         Assert.IsNull (r.Type, "#71-3");
 831                         Assert.IsNull (r.Member, "#71-4");
 832                         Assert.IsNull (r.Value, "#71-5");
 833
 834                         Assert.IsTrue (r.Read (), "#72");
 835                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 836                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 837
 838                         string [] values = {"5", "-3", "0"};
 839                         for (int i = 0; i < 3; i++) {
 840                                 Assert.IsTrue (r.Read (), i + "#73");
 841                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 842                                 Assert.IsTrue (r.Read (), i + "#74");
 843                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 844                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 845                                 Assert.IsTrue (r.Read (), i + "#75");
 846                                 Assert.IsNotNull (r.Value, i + "#75-2");
 847                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 848                                 Assert.IsTrue (r.Read (), i + "#74");
 849                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 850                                 Assert.IsTrue (r.Read (), i + "#75");
 851                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 852                         }
 853
 854                         Assert.IsTrue (r.Read (), "#81");
 855                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 856
 857                         Assert.IsTrue (r.Read (), "#83");
 858                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
 859
 860                         Assert.IsTrue (r.Read (), "#85");
 861                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ArrayExtension.Items
 862
 863                         Assert.IsTrue (r.Read (), "#87");
 864                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ArrayExtension
 865
 866                         Assert.IsFalse (r.Read (), "#89");
 867                 }
 868
 869                 [Test] // It gives Type member, not PositionalParameters... and no Items member here.
 870                 public void Read_ArrayExtension2 ()
 871                 {
 872                         var r = new XamlObjectReader (new ArrayExtension (typeof (int)));
 873                         Assert.IsTrue (r.Read (), "#11");
 874                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 875                         Assert.IsNotNull (r.Namespace, "#13");
 876                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 877                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 878                         Assert.IsNull (r.Instance, "#14");
 879
 880                         Assert.IsTrue (r.Read (), "#21");
 881                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 882                         var xt = new XamlType (typeof (ArrayExtension), r.SchemaContext);
 883                         Assert.AreEqual (xt, r.Type, "#23-2");
 884                         Assert.IsTrue (r.Instance is ArrayExtension, "#26");
 885
 886                         Assert.IsTrue (r.Read (), "#31");
 887                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 888                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33-2");
 889
 890                         Assert.IsTrue (r.Read (), "#41");
 891                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 892                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 893
 894                         Assert.IsTrue (r.Read (), "#51");
 895                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 896
 897                         Assert.IsTrue (r.Read (), "#61");
 898                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 899
 900                         Assert.IsFalse (r.Read (), "#71");
 901                         Assert.IsTrue (r.IsEof, "#72");
 902                 }
 903
 904                 [Test]
 905                 public void Read_DateTime ()
 906                 {
 907                         var obj = new DateTime (2010, 4, 15);
 908                         var r = new XamlObjectReader (obj);
 909                         Read_CommonClrType (r, obj);
 910                         Assert.AreEqual ("2010-04-15", Read_Initialization (r, null), "#1");
 911                 }
 912
 913                 [Test]
 914                 public void Read_TimeSpan ()
 915                 {
 916                         Read_CommonXamlPrimitive (TimeSpan.FromMinutes (4));
 917                 }
 918
 919                 [Test]
 920                 public void Read_Uri ()
 921                 {
 922                         Read_CommonXamlPrimitive (new Uri ("urn:foo"));
 923                 }
 924
 925                 [Test]
 926                 public void Read_Guid ()
 927                 {
 928                         var obj = Guid.NewGuid ();
 929                         var r = new XamlObjectReader (obj);
 930                         Assert.IsNotNull (r.SchemaContext.GetXamlType (typeof (Guid)).TypeConverter, "premise#1");
 931                         Read_CommonClrType (r, obj);
 932                         Assert.AreEqual (obj.ToString (), Read_Initialization (r, null), "#1");
 933                 }
 934
 935                 [Test]
 936                 [ExpectedException (typeof (XamlObjectReaderException))]
 937                 [Category ("NotWorking")]
 938                 public void Read_XData ()
 939                 {
 940                         var r = new XamlObjectReader (new XData () {Text = "xdata text"}); // XmlReader implementation is not visible.
 941                         while (!r.IsEof)
 942                                 r.Read ();
 943                 }
 944
 945                 [Test]
 946                 public void ReadStandardTypes ()
 947                 {
 948                         SimpleReadStandardType (new ArrayExtension ());
 949                         SimpleReadStandardType (new NullExtension ());
 950                         SimpleReadStandardType (new PropertyDefinition ());
 951                         SimpleReadStandardType (new Reference ());
 952                         SimpleReadStandardType (new StaticExtension ());
 953                         SimpleReadStandardType (new TypeExtension ());
 954                 }
 955
 956                 [Test]
 957                 public void Read_CustomMarkupExtension ()
 958                 {
 959                         var r = new XamlObjectReader (new MyExtension () { Foo = typeof (int), Bar = "v2", Baz = "v7"});
 960                         r.Read (); // ns
 961                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 962                         r.Read (); // ns
 963                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-2");
 964                         r.Read ();
 965                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
 966                         Assert.IsFalse (r.IsEof, "#1");
 967                         var xt = r.Type;
 968
 969                         r.Read ();
 970                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#2-1");
 971                         Assert.IsFalse (r.IsEof, "#2-2");
 972                         Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#2-3");
 973
 974                         Assert.IsTrue (r.Read (), "#2-4");
 975                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#2-5");
 976                         Assert.AreEqual ("v2", r.Value, "#2-6");
 977
 978                         Assert.IsTrue (r.Read (), "#2-7");
 979                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#2-8");
 980
 981                         r.Read ();
 982                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-1");
 983                         Assert.IsFalse (r.IsEof, "#3-2");
 984                         Assert.AreEqual (xt.GetMember ("Baz"), r.Member, "#3-3");
 985
 986                         Assert.IsTrue (r.Read (), "#3-4");
 987                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#3-5");
 988                         Assert.AreEqual ("v7", r.Value, "#3-6");
 989
 990                         Assert.IsTrue (r.Read (), "#3-7");
 991                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#3-8");
 992
 993                         r.Read ();
 994                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#4-1");
 995                         Assert.IsFalse (r.IsEof, "#4-2");
 996                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4-3");
 997                         Assert.IsTrue (r.Read (), "#4-4");
 998                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#4-5");
 999                         Assert.AreEqual ("x:Int32", r.Value, "#4-6");
1000
1001                         Assert.IsTrue (r.Read (), "#4-7");
1002                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#4-8");
1003
1004                         Assert.IsTrue (r.Read (), "#5");
1005                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#5-2");
1006
1007                         Assert.IsFalse (r.Read (), "#6");
1008                 }
1009
1010                 [Test]
1011                 public void Read_CustomMarkupExtension2 ()
1012                 {
1013                         var r = new XamlObjectReader (new MyExtension2 () { Foo = typeof (int), Bar = "v2"});
1014                         r.Read (); // ns
1015                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1016                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1017                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1018                         var xt = r.Type;
1019                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension2)), xt, "#2");
1020                         Assert.IsTrue (r.Read (), "#3");
1021                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1022                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1023                         Assert.IsTrue (r.Read (), "#5");
1024                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension2", r.Value, "#6");
1025                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1026                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1027                         Assert.IsFalse (r.Read (), "#9");
1028                 }
1029
1030                 [Test]
1031                 public void Read_CustomMarkupExtension3 ()
1032                 {
1033                         var r = new XamlObjectReader (new MyExtension3 () { Foo = typeof (int), Bar = "v2"});
1034                         r.Read (); // ns
1035                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1036                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1037                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1038                         var xt = r.Type;
1039                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension3)), xt, "#2");
1040                         Assert.IsTrue (r.Read (), "#3");
1041                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1042                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1043                         Assert.IsTrue (r.Read (), "#5");
1044                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension3", r.Value, "#6");
1045                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1046                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1047                         Assert.IsFalse (r.Read (), "#9");
1048                 }
1049
1050                 [Test]
1051                 public void Read_CustomMarkupExtension4 ()
1052                 {
1053                         var r = new XamlObjectReader (new MyExtension4 () { Foo = typeof (int), Bar = "v2"});
1054                         r.Read (); // ns
1055                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1056                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1057                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1058                         var xt = r.Type;
1059                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension4)), xt, "#2");
1060                         Assert.IsTrue (r.Read (), "#3");
1061                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1062                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1063                         Assert.IsTrue (r.Read (), "#5");
1064                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension4", r.Value, "#6");
1065                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1066                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1067                         Assert.IsFalse (r.Read (), "#9");
1068                 }
1069
1070                 [Test]
1071                 [Category ("NotWorking")]
1072                 public void Read_CustomMarkupExtension5 ()
1073                 {
1074                         // This cannot be written to XamlXmlWriter though...
1075
1076                         var r = new XamlObjectReader (new MyExtension5 ("foo", "bar"));
1077                         r.Read (); // ns
1078                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1079                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1080                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1081                         var xt = r.Type;
1082                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension5)), xt, "#2");
1083                         Assert.IsTrue (r.Read (), "#3");
1084                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1085                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#4");
1086                         Assert.IsTrue (r.Read (), "#5");
1087                         Assert.AreEqual ("foo", r.Value, "#6");
1088                         Assert.IsTrue (r.Read (), "#7");
1089                         Assert.AreEqual ("bar", r.Value, "#8");
1090                         Assert.IsTrue (r.Read (), "#9");
1091                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#10");
1092                         Assert.IsTrue (r.Read (), "#11");
1093                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#12");
1094                         Assert.IsFalse (r.Read (), "#13");
1095                 }
1096
1097                 [Test]
1098                 [Category ("NotWorking")]
1099                 public void Read_CustomMarkupExtension6 ()
1100                 {
1101                         var r = new XamlObjectReader (new MyExtension6 ("foo"));
1102                         r.Read (); // ns
1103                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1104                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1105                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1106                         var xt = r.Type;
1107                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension6)), xt, "#2");
1108                         Assert.IsTrue (r.Read (), "#3");
1109                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1110                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4"); // this is the difference between MyExtension5 and MyExtension6: it outputs constructor arguments as normal members
1111                         Assert.IsTrue (r.Read (), "#5");
1112                         Assert.AreEqual ("foo", r.Value, "#6");
1113                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1114                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1115                         Assert.IsFalse (r.Read (), "#9");
1116                 }
1117
1118                 [Test]
1119                 public void Read_ArgumentAttributed ()
1120                 {
1121                         var obj = new ArgumentAttributed ("foo", "bar");
1122                         var r = new XamlObjectReader (obj);
1123                         Read_CommonClrType (r, obj, new KeyValuePair<string,string> ("x", XamlLanguage.Xaml2006Namespace));
1124                         var args = Read_AttributedArguments_String (r, new string [] {"arg1", "arg2"});
1125                         Assert.AreEqual ("foo", args [0], "#1");
1126                         Assert.AreEqual ("bar", args [1], "#2");
1127                 }
1128
1129                 [Test]
1130                 public void Read_Dictionary ()
1131                 {
1132                         var obj = new Dictionary<string,object> ();
1133                         obj ["Foo"] = 5.0;
1134                         obj ["Bar"] = -6.5;
1135                         var r = new XamlObjectReader (obj);
1136
1137                         Assert.IsTrue (r.Read (), "ns#1-1");
1138                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1139                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1140                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1141                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "ns#1-5");
1142
1143                         Assert.IsTrue (r.Read (), "ns#2-1");
1144                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1145                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1146                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1147                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1148
1149                         Assert.IsTrue (r.Read (), "so#1-1");
1150                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1151                         var xt = new XamlType (typeof (Dictionary<string,object>), r.SchemaContext);
1152                         Assert.AreEqual (xt, r.Type, "so#1-3");
1153                         Assert.AreEqual (obj, r.Instance, "so#1-4");
1154
1155                         Assert.IsTrue (r.Read (), "smitems#1");
1156                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smitems#2");
1157                         Assert.AreEqual (XamlLanguage.Items, r.Member, "smitems#3");
1158
1159                         for (int i = 0; i < 2; i++) {
1160
1161                                 // start of an item
1162                                 Assert.IsTrue (r.Read (), "soi#1-1." + i);
1163                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "soi#1-2." + i);
1164                                 var xt2 = new XamlType (typeof (double), r.SchemaContext);
1165                                 Assert.AreEqual (xt2, r.Type, "soi#1-3." + i);
1166
1167                                 Assert.IsTrue (r.Read (), "smi#1-1." + i);
1168                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#1-2." + i);
1169                                 Assert.AreEqual (XamlLanguage.Key, r.Member, "smi#1-3." + i);
1170
1171                                 Assert.IsTrue (r.Read (), "svi#1-1." + i);
1172                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#1-2." + i);
1173                                 Assert.AreEqual (i == 0 ? "Foo" : "Bar", r.Value, "svi#1-3." + i);
1174
1175                                 Assert.IsTrue (r.Read (), "emi#1-1." + i);
1176                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#1-2." + i);
1177
1178                                 Assert.IsTrue (r.Read (), "smi#2-1." + i);
1179                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#2-2." + i);
1180                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, "smi#2-3." + i);
1181
1182                                 Assert.IsTrue (r.Read (), "svi#2-1." + i);
1183                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#2-2." + i);
1184                                 Assert.AreEqual (i == 0 ? "5" : "-6.5", r.Value, "svi#2-3." + i); // converted to string(!)
1185
1186                                 Assert.IsTrue (r.Read (), "emi#2-1." + i);
1187                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#2-2." + i);
1188
1189                                 Assert.IsTrue (r.Read (), "eoi#1-1." + i);
1190                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eoi#1-2." + i);
1191                                 // end of an item
1192                         }
1193
1194                         Assert.IsTrue (r.Read (), "emitems#1");
1195                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emitems#2"); // XamlLanguage.Items
1196
1197                         Assert.IsTrue (r.Read (), "eo#1-1");
1198                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2"); // Dictionary
1199
1200                         Assert.IsFalse (r.Read (), "end");
1201                 }
1202
1203                 [Test]
1204                 [Category ("NotWorking")]
1205                 public void PositionalParameters1 ()
1206                 {
1207                         // ns1 > T:PositionalParametersClass1 > M:_PositionalParameters > foo > 5 > EM:_PositionalParameters > ET:PositionalParametersClass1
1208
1209                         // Note: this can be read, but cannot be written to XML.
1210                         var obj = new PositionalParametersClass1 ("foo", 5);
1211                         var r = new XamlObjectReader (obj);
1212
1213                         Assert.IsTrue (r.Read (), "ns#1-1");
1214                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1215                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1216                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1217                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1218
1219                         Assert.IsTrue (r.Read (), "so#1-1");
1220                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1221                         var xt = new XamlType (typeof (PositionalParametersClass1), r.SchemaContext);
1222                         Assert.AreEqual (xt, r.Type, "so#1-3");
1223                         Assert.AreEqual (obj, r.Instance, "so#1-4");
1224
1225                         Assert.IsTrue (r.Read (), "sposprm#1");
1226                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1227                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "sposprm#3");
1228
1229                         Assert.IsTrue (r.Read (), "sva#1-1");
1230                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1231                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1232
1233                         Assert.IsTrue (r.Read (), "sva#2-1");
1234                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#2-2");
1235                         Assert.AreEqual ("5", r.Value, "sva#2-3");
1236
1237                         Assert.IsTrue (r.Read (), "eposprm#1");
1238                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2"); // XamlLanguage.PositionalParameters
1239
1240                         Assert.IsTrue (r.Read (), "eo#1-1");
1241                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1242
1243                         Assert.IsFalse (r.Read (), "end");
1244                 }
1245
1246                 [Test]
1247                 [Category ("NotWorking")]
1248                 public void PositionalParameters2 ()
1249                 {
1250                         // ns1 > T:PositionalParametersWrapper > M:Body > T:PositionalParametersClass1 > M:_PositionalParameters > foo > 5 > EM:_PositionalParameters > ET:PositionalParametersClass1
1251
1252                         var obj = new PositionalParametersWrapper ("foo", 5);
1253                         var r = new XamlObjectReader (obj);
1254
1255                         Assert.IsTrue (r.Read (), "ns#1-1");
1256                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1257                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1258                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1259                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1260
1261                         Assert.IsTrue (r.Read (), "so#1-1");
1262                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1263                         var xt = new XamlType (typeof (PositionalParametersWrapper), r.SchemaContext);
1264                         Assert.AreEqual (xt, r.Type, "so#1-3");
1265                         Assert.AreEqual (obj, r.Instance, "so#1-4");
1266
1267                         Assert.IsTrue (r.Read (), "sm#1-1");
1268                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#1-2");
1269                         Assert.AreEqual (xt.GetMember ("Body"), r.Member, "sm#1-3");
1270
1271                         xt = new XamlType (typeof (PositionalParametersClass1), r.SchemaContext);
1272                         Assert.IsTrue (r.Read (), "so#2-1");
1273                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1274                         Assert.AreEqual (xt, r.Type, "so#2-3");
1275                         Assert.AreEqual (obj.Body, r.Instance, "so#2-4");
1276
1277                         Assert.IsTrue (r.Read (), "sposprm#1");
1278                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1279                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "sposprm#3");
1280
1281                         Assert.IsTrue (r.Read (), "sva#1-1");
1282                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1283                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1284
1285                         Assert.IsTrue (r.Read (), "sva#2-1");
1286                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#2-2");
1287                         Assert.AreEqual ("5", r.Value, "sva#2-3");
1288
1289                         Assert.IsTrue (r.Read (), "eposprm#1");
1290                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2"); // XamlLanguage.PositionalParameters
1291
1292                         Assert.IsTrue (r.Read (), "eo#2-1");
1293                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1294
1295                         Assert.IsTrue (r.Read (), "em#1-1");
1296                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eo#1-2");
1297
1298                         Assert.IsTrue (r.Read (), "eo#1-1");
1299                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1300
1301                         Assert.IsFalse (r.Read (), "end");
1302                 }
1303
1304                 [Test]
1305                 [Category ("NotWorking")]
1306                 public void ComplexPositionalParameters ()
1307                 {
1308                         var obj = new ComplexPositionalParameterWrapper () { Param = new ComplexPositionalParameterClass (new ComplexPositionalParameterValue () { Foo = "foo" })};
1309                         var r = new XamlObjectReader (obj);
1310
1311                         Assert.IsTrue (r.Read (), "ns#1-1");
1312                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1313                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1314                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1315                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1316
1317                         Assert.IsTrue (r.Read (), "ns#2-1");
1318                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1319                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1320                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1321                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1322
1323                         Assert.IsTrue (r.Read (), "so#1-1");
1324                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1325                         var xt = new XamlType (obj.GetType (), r.SchemaContext);
1326                         Assert.AreEqual (xt, r.Type, "so#1-3");
1327                         Assert.AreEqual (obj, r.Instance, "so#1-4");
1328
1329                         Assert.IsTrue (r.Read (), "sm#1-1");
1330                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#1-2");
1331                         Assert.AreEqual (xt.GetMember ("Param"), r.Member, "sm#1-3");
1332
1333                         xt = r.SchemaContext.GetXamlType (typeof (ComplexPositionalParameterClass));
1334                         Assert.IsTrue (r.Read (), "so#2-1");
1335                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1336                         Assert.AreEqual (xt, r.Type, "so#2-3");
1337                         Assert.AreEqual (obj.Param, r.Instance, "so#2-4");
1338
1339                         Assert.IsTrue (r.Read (), "sarg#1");
1340                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sarg#2");
1341                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "sarg#3");
1342
1343                         Assert.IsTrue (r.Read (), "so#3-1");
1344                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#3-2");
1345                         xt = r.SchemaContext.GetXamlType (typeof (ComplexPositionalParameterValue));
1346                         Assert.AreEqual (xt, r.Type, "so#3-3");
1347
1348                         Assert.IsTrue (r.Read (), "sm#3-1");
1349                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#3-2");
1350                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "sm#3-3");
1351                         Assert.IsTrue (r.Read (), "v#3-1");
1352                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "v#3-2");
1353                         Assert.AreEqual ("foo", r.Value, "v#3-3");
1354
1355                         Assert.IsTrue (r.Read (), "em#3-1");
1356                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em#3-2");
1357                         Assert.IsTrue (r.Read (), "eo#3-1");
1358                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#3-2");
1359
1360                         Assert.IsTrue (r.Read (), "earg#1");
1361                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "earg#2"); // XamlLanguage.Arguments
1362
1363                         Assert.IsTrue (r.Read (), "eo#2-1");
1364                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1365
1366                         Assert.IsTrue (r.Read (), "em#1-1");
1367                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eo#1-2");
1368
1369                         Assert.IsTrue (r.Read (), "eo#1-1");
1370                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1371
1372                         Assert.IsFalse (r.Read (), "end");
1373                 }
1374
1375                 [Test]
1376                 [Category ("NotWorking")]
1377                 public void Read_ListWrapper ()
1378                 {
1379                         var obj = new ListWrapper (new List<int> (new int [] {5, -3, 0}));
1380                         var r = new XamlObjectReader (obj);
1381
1382                         Assert.IsTrue (r.Read (), "#1");
1383                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
1384                         Assert.IsNotNull (r.Namespace, "#3");
1385                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
1386
1387                         Assert.IsTrue (r.Read (), "#11");
1388                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
1389                         Assert.IsNotNull (r.Namespace, "#13");
1390                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
1391                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
1392
1393                         Assert.IsTrue (r.Read (), "#21");
1394                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
1395                         var xt = new XamlType (obj.GetType (), r.SchemaContext);
1396                         Assert.AreEqual (xt, r.Type, "#23");
1397                         Assert.AreEqual (obj, r.Instance, "#26");
1398
1399                         Assert.IsTrue (r.Read (), "#61");
1400                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
1401                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
1402
1403                         Assert.IsTrue (r.Read (), "#71");
1404                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
1405                         Assert.IsNull (r.Type, "#71-3");
1406                         Assert.IsNull (r.Member, "#71-4");
1407                         Assert.IsNull (r.Value, "#71-5");
1408
1409                         Assert.IsTrue (r.Read (), "#72");
1410                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
1411                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
1412
1413                         string [] values = {"5", "-3", "0"};
1414                         for (int i = 0; i < 3; i++) {
1415                                 Assert.IsTrue (r.Read (), i + "#73");
1416                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
1417                                 Assert.IsTrue (r.Read (), i + "#74");
1418                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
1419                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
1420                                 Assert.IsTrue (r.Read (), i + "#75");
1421                                 Assert.IsNotNull (r.Value, i + "#75-2");
1422                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
1423                                 Assert.IsTrue (r.Read (), i + "#74");
1424                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
1425                                 Assert.IsTrue (r.Read (), i + "#75");
1426                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
1427                         }
1428
1429                         Assert.IsTrue (r.Read (), "#81");
1430                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
1431
1432                         Assert.IsTrue (r.Read (), "#83");
1433                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
1434
1435                         Assert.IsTrue (r.Read (), "#85");
1436                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ListWrapper.Items
1437
1438                         Assert.IsTrue (r.Read (), "#87");
1439                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ListWrapper
1440
1441                         Assert.IsFalse (r.Read (), "#89");
1442                 }
1443
1444                 [Test]
1445                 [Category ("NotWorking")]
1446                 public void Read_ListWrapper2 () // read-write list member.
1447                 {
1448                         var obj = new ListWrapper2 (new List<int> (new int [] {5, -3, 0}));
1449                         var r = new XamlObjectReader (obj);
1450
1451                         Assert.IsTrue (r.Read (), "#1");
1452                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
1453                         Assert.IsNotNull (r.Namespace, "#3");
1454                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
1455
1456                         Assert.IsTrue (r.Read (), "#6");
1457                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
1458                         Assert.IsNotNull (r.Namespace, "#8");
1459                         Assert.AreEqual ("scg", r.Namespace.Prefix, "#8-2");
1460                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "#8-3");
1461
1462                         Assert.IsTrue (r.Read (), "#11");
1463                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
1464                         Assert.IsNotNull (r.Namespace, "#13");
1465                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
1466                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
1467
1468                         Assert.IsTrue (r.Read (), "#21");
1469                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
1470                         var xt = new XamlType (obj.GetType (), r.SchemaContext);
1471                         Assert.AreEqual (xt, r.Type, "#23");
1472                         Assert.AreEqual (obj, r.Instance, "#26");
1473
1474                         Assert.IsTrue (r.Read (), "#61");
1475                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
1476                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
1477
1478                         Assert.IsTrue (r.Read (), "#71");
1479                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#71-2");
1480                         xt = r.SchemaContext.GetXamlType (typeof (List<int>));
1481                         Assert.AreEqual (xt, r.Type, "#71-3");
1482                         Assert.IsNull (r.Member, "#71-4");
1483                         Assert.IsNull (r.Value, "#71-5");
1484
1485                         // Capacity
1486                         Assert.IsTrue (r.Read (), "#31");
1487                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
1488                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
1489
1490                         Assert.IsTrue (r.Read (), "#41");
1491                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
1492                         // The value is implementation details, not testable.
1493                         //Assert.AreEqual ("3", r.Value, "#43");
1494
1495                         Assert.IsTrue (r.Read (), "#51");
1496                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
1497
1498                         // Items
1499                         Assert.IsTrue (r.Read (), "#72");
1500                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
1501                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
1502
1503                         string [] values = {"5", "-3", "0"};
1504                         for (int i = 0; i < 3; i++) {
1505                                 Assert.IsTrue (r.Read (), i + "#73");
1506                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
1507                                 Assert.IsTrue (r.Read (), i + "#74");
1508                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
1509                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
1510                                 Assert.IsTrue (r.Read (), i + "#75");
1511                                 Assert.IsNotNull (r.Value, i + "#75-2");
1512                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
1513                                 Assert.IsTrue (r.Read (), i + "#74");
1514                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
1515                                 Assert.IsTrue (r.Read (), i + "#75");
1516                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
1517                         }
1518
1519                         Assert.IsTrue (r.Read (), "#81");
1520                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
1521
1522                         Assert.IsTrue (r.Read (), "#83");
1523                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // StartObject(of List<int>)
1524
1525                         Assert.IsTrue (r.Read (), "#85");
1526                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ListWrapper.Items
1527
1528                         Assert.IsTrue (r.Read (), "#87");
1529                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ListWrapper
1530
1531                         Assert.IsFalse (r.Read (), "#89");
1532                 }
1533
1534                 void SimpleReadStandardType (object instance)
1535                 {
1536                         var r = new XamlObjectReader (instance);
1537                         while (!r.IsEof)
1538                                 r.Read ();
1539                 }
1540
1541                 void Read_CommonXamlPrimitive (object obj)
1542                 {
1543                         var r = new XamlObjectReader (obj);
1544                         Read_CommonXamlType (r);
1545                         Read_Initialization (r, obj);
1546                 }
1547
1548                 // from StartMember of Initialization to EndMember
1549                 string Read_Initialization (XamlObjectReader r, object comparableValue)
1550                 {
1551                         Assert.IsTrue (r.Read (), "init#1");
1552                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "init#2");
1553                         Assert.IsNotNull (r.Member, "init#3");
1554                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "init#3-2");
1555                         Assert.IsTrue (r.Read (), "init#4");
1556                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "init#5");
1557                         Assert.AreEqual (typeof (string), r.Value.GetType (), "init#6");
1558                         string ret = (string) r.Value;
1559                         if (comparableValue != null)
1560                                 Assert.AreEqual (comparableValue.ToString (), r.Value, "init#6-2");
1561                         Assert.IsTrue (r.Read (), "init#7");
1562                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "init#8");
1563                         return ret;
1564                 }
1565
1566                 object [] Read_AttributedArguments_String (XamlObjectReader r, string [] argNames) // valid only for string arguments.
1567                 {
1568                         object [] ret = new object [argNames.Length];
1569
1570                         Assert.IsTrue (r.Read (), "attarg.Arguments.Start1");
1571                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.Arguments.Start2");
1572                         Assert.IsNotNull (r.Member, "attarg.Arguments.Start3");
1573                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "attarg.Arguments.Start4");
1574                         for (int i = 0; i < argNames.Length; i++) {
1575                                 string arg = argNames [i];
1576                                 Assert.IsTrue (r.Read (), "attarg.ArgStartObject1." + arg);
1577                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "attarg.ArgStartObject2." + arg);
1578                                 Assert.AreEqual (typeof (string), r.Type.UnderlyingType, "attarg.ArgStartObject3." + arg);
1579                                 Assert.IsTrue (r.Read (), "attarg.ArgStartMember1." + arg);
1580                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.ArgStartMember2." + arg);
1581                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, "attarg.ArgStartMember3." + arg); // (as the argument is string here by definition)
1582                                 Assert.IsTrue (r.Read (), "attarg.ArgValue1." + arg);
1583                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "attarg.ArgValue2." + arg);
1584                                 Assert.AreEqual (typeof (string), r.Value.GetType (), "attarg.ArgValue3." + arg);
1585                                 ret [i] = r.Value;
1586                                 Assert.IsTrue (r.Read (), "attarg.ArgEndMember1." + arg);
1587                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.ArgEndMember2." + arg);
1588                                 Assert.IsTrue (r.Read (), "attarg.ArgEndObject1." + arg);
1589                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "attarg.ArgEndObject2." + arg);
1590                         }
1591                         Assert.IsTrue (r.Read (), "attarg.Arguments.End1");
1592                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.Arguments.End2");
1593                         return ret;
1594                 }
1595
1596                 // from initial to StartObject
1597                 void Read_CommonXamlType (XamlObjectReader r)
1598                 {
1599                         Assert.IsTrue (r.Read (), "ct#1");
1600                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
1601                         Assert.IsNotNull (r.Namespace, "ct#3");
1602                         Assert.AreEqual ("x", r.Namespace.Prefix, "ct#3-2");
1603                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ct#3-3");
1604                         Assert.IsNull (r.Instance, "ct#4");
1605
1606                         Assert.IsTrue (r.Read (), "ct#5");
1607                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#6");
1608                 }
1609
1610                 // from initial to StartObject
1611                 void Read_CommonClrType (XamlObjectReader r, object obj, params KeyValuePair<string,string> [] additionalNamespaces)
1612                 {
1613                         Assert.IsTrue (r.Read (), "ct#1");
1614                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
1615                         Assert.IsNotNull (r.Namespace, "ct#3");
1616                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ct#3-2");
1617                         Assert.AreEqual ("clr-namespace:" + obj.GetType ().Namespace + ";assembly=" + obj.GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ct#3-3");
1618
1619                         foreach (var kvp in additionalNamespaces) {
1620                                 Assert.IsTrue (r.Read (), "ct#4." + kvp.Key);
1621                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#5." + kvp.Key);
1622                                 Assert.IsNotNull (r.Namespace, "ct#6." + kvp.Key);
1623                                 Assert.AreEqual (kvp.Key, r.Namespace.Prefix, "ct#6-2." + kvp.Key);
1624                                 Assert.AreEqual (kvp.Value, r.Namespace.Namespace, "ct#6-3." + kvp.Key);
1625                         }
1626
1627                         Assert.IsTrue (r.Read (), "ct#7");
1628                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#8");
1629                 }
1630         }
1631 }