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                 public void Read_ListInt32_2 ()
 614                 {
 615                         var obj = new List<int> (new int [0]);
 616                         Read_ListInt32 (obj);
 617                 }
 618
 619                 void Read_ListInt32 (List<int> obj)
 620                 {
 621                         var r = new XamlObjectReader (obj);
 622                         Assert.IsTrue (r.Read (), "ns#1-1");
 623                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
 624
 625                         var defns = "clr-namespace:System.Collections.Generic;assembly=mscorlib";
 626
 627                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3");
 628                         Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4");
 629
 630                         Assert.IsTrue (r.Read (), "#11");
 631                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 632                         Assert.IsNotNull (r.Namespace, "#13");
 633                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 634                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 635
 636                         Assert.IsTrue (r.Read (), "#21");
 637                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 638                         var xt = new XamlType (typeof (List<int>), r.SchemaContext);
 639                         Assert.AreEqual (xt, r.Type, "#23");
 640                         Assert.AreEqual (obj, r.Instance, "#26");
 641                         Assert.IsTrue (xt.IsCollection, "#27");
 642
 643                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 644
 645                         Assert.IsTrue (r.Read (), "#31");
 646                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 647                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
 648
 649                         Assert.IsTrue (r.Read (), "#41");
 650                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 651                         // The value is implementation details, not testable.
 652                         //Assert.AreEqual ("3", r.Value, "#43");
 653
 654                         Assert.IsTrue (r.Read (), "#51");
 655                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 656
 657                         if (obj.Count > 0) { // only when items exist.
 658
 659                         Assert.IsTrue (r.Read (), "#72");
 660                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 661                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 662
 663                         string [] values = {"5", "-3", "0"};
 664                         for (int i = 0; i < 3; i++) {
 665                                 Assert.IsTrue (r.Read (), i + "#73");
 666                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 667                                 Assert.IsTrue (r.Read (), i + "#74");
 668                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 669                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 670                                 Assert.IsTrue (r.Read (), i + "#75");
 671                                 Assert.IsNotNull (r.Value, i + "#75-2");
 672                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 673                                 Assert.IsTrue (r.Read (), i + "#74");
 674                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 675                                 Assert.IsTrue (r.Read (), i + "#75");
 676                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 677                         }
 678
 679                         Assert.IsTrue (r.Read (), "#81");
 680                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 681
 682                         } // end of "if count > 0".
 683
 684                         Assert.IsTrue (r.Read (), "#87");
 685                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88");
 686
 687                         Assert.IsFalse (r.Read (), "#89");
 688                 }
 689
 690                 [Test]
 691                 public void Read_ArrayList ()
 692                 {
 693                         var obj = new ArrayList (new int [] {5, -3, 0});
 694
 695                         var r = new XamlObjectReader (obj);
 696                         Assert.IsTrue (r.Read (), "ns#1-1");
 697                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
 698
 699                         var defns = "clr-namespace:System.Collections;assembly=mscorlib";
 700
 701                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3");
 702                         Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4");
 703
 704                         Assert.IsTrue (r.Read (), "#11");
 705                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 706                         Assert.IsNotNull (r.Namespace, "#13");
 707                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 708                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 709
 710                         Assert.IsTrue (r.Read (), "#21");
 711                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 712                         var xt = new XamlType (typeof (ArrayList), r.SchemaContext);
 713                         Assert.AreEqual (xt, r.Type, "#23");
 714                         Assert.AreEqual (obj, r.Instance, "#26");
 715                         Assert.IsTrue (xt.IsCollection, "#27");
 716
 717                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 718
 719                         Assert.IsTrue (r.Read (), "#31");
 720                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 721                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
 722
 723                         Assert.IsTrue (r.Read (), "#41");
 724                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 725                         // The value is implementation details, not testable.
 726                         //Assert.AreEqual ("3", r.Value, "#43");
 727
 728                         Assert.IsTrue (r.Read (), "#51");
 729                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 730
 731                         Assert.IsTrue (r.Read (), "#72");
 732                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 733                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 734
 735                         string [] values = {"5", "-3", "0"};
 736                         for (int i = 0; i < 3; i++) {
 737                                 Assert.IsTrue (r.Read (), i + "#73");
 738                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 739                                 Assert.IsTrue (r.Read (), i + "#74");
 740                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 741                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 742                                 Assert.IsTrue (r.Read (), i + "#75");
 743                                 Assert.IsNotNull (r.Value, i + "#75-2");
 744                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 745                                 Assert.IsTrue (r.Read (), i + "#74");
 746                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 747                                 Assert.IsTrue (r.Read (), i + "#75");
 748                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 749                         }
 750
 751                         Assert.IsTrue (r.Read (), "#81");
 752                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 753
 754                         Assert.IsTrue (r.Read (), "#87");
 755                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88");
 756
 757                         Assert.IsFalse (r.Read (), "#89");
 758                 }
 759
 760                 [Test]
 761                 public void Read_Array ()
 762                 {
 763                         var obj = new int [] {5, -3, 0};
 764                         var r = new XamlObjectReader (obj);
 765                         Read_ArrayOrArrayExtension (r, obj);
 766                 }
 767
 768                 [Test]
 769                 public void Read_ArrayExtension ()
 770                 {
 771                         var obj = new ArrayExtension (new int [] {5, -3, 0});
 772                         var r = new XamlObjectReader (obj);
 773                         Read_ArrayOrArrayExtension (r, obj);
 774                 }
 775
 776                 [Test]
 777                 public void Read_MyArrayExtension ()
 778                 {
 779                         var obj = new MyArrayExtension (new int [] {5, -3, 0});
 780                         var r = new XamlObjectReader (obj);
 781                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, obj, typeof (MyArrayExtension));
 782                 }
 783
 784                 void Read_ArrayOrArrayExtension (XamlObjectReader r, object instance)
 785                 {
 786                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, instance, typeof (ArrayExtension));
 787                 }
 788
 789                 void Read_ArrayOrArrayExtensionOrMyArrayExtension (XamlObjectReader r, object instance, Type extType)
 790                 {
 791                         if (extType == typeof (MyArrayExtension)) {
 792                                 Assert.IsTrue (r.Read (), "#1");
 793                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
 794                                 Assert.IsNotNull (r.Namespace, "#3");
 795                                 Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
 796                         }
 797                         Assert.IsTrue (r.Read (), "#11");
 798                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 799                         Assert.IsNotNull (r.Namespace, "#13");
 800                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 801                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 802
 803                         Assert.IsTrue (r.Read (), "#21");
 804                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 805                         var xt = new XamlType (extType, r.SchemaContext);
 806                         Assert.AreEqual (xt, r.Type, "#23");
 807                         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)
 808
 809                         // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future.
 810
 811                         Assert.IsTrue (r.Read (), "#31");
 812                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 813                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33");
 814
 815                         Assert.IsTrue (r.Read (), "#41");
 816                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 817                         Assert.AreEqual ("x:Int32", r.Value, "#43");
 818
 819                         Assert.IsTrue (r.Read (), "#51");
 820                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 821
 822                         Assert.IsTrue (r.Read (), "#61");
 823                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
 824                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
 825
 826                         Assert.IsTrue (r.Read (), "#71");
 827                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
 828                         Assert.IsNull (r.Type, "#71-3");
 829                         Assert.IsNull (r.Member, "#71-4");
 830                         Assert.IsNull (r.Value, "#71-5");
 831
 832                         Assert.IsTrue (r.Read (), "#72");
 833                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 834                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 835
 836                         string [] values = {"5", "-3", "0"};
 837                         for (int i = 0; i < 3; i++) {
 838                                 Assert.IsTrue (r.Read (), i + "#73");
 839                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 840                                 Assert.IsTrue (r.Read (), i + "#74");
 841                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 842                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 843                                 Assert.IsTrue (r.Read (), i + "#75");
 844                                 Assert.IsNotNull (r.Value, i + "#75-2");
 845                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 846                                 Assert.IsTrue (r.Read (), i + "#74");
 847                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 848                                 Assert.IsTrue (r.Read (), i + "#75");
 849                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 850                         }
 851
 852                         Assert.IsTrue (r.Read (), "#81");
 853                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 854
 855                         Assert.IsTrue (r.Read (), "#83");
 856                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
 857
 858                         Assert.IsTrue (r.Read (), "#85");
 859                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ArrayExtension.Items
 860
 861                         Assert.IsTrue (r.Read (), "#87");
 862                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ArrayExtension
 863
 864                         Assert.IsFalse (r.Read (), "#89");
 865                 }
 866
 867                 [Test] // It gives Type member, not PositionalParameters... and no Items member here.
 868                 public void Read_ArrayExtension2 ()
 869                 {
 870                         var r = new XamlObjectReader (new ArrayExtension (typeof (int)));
 871                         Assert.IsTrue (r.Read (), "#11");
 872                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 873                         Assert.IsNotNull (r.Namespace, "#13");
 874                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 875                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 876                         Assert.IsNull (r.Instance, "#14");
 877
 878                         Assert.IsTrue (r.Read (), "#21");
 879                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 880                         var xt = new XamlType (typeof (ArrayExtension), r.SchemaContext);
 881                         Assert.AreEqual (xt, r.Type, "#23-2");
 882                         Assert.IsTrue (r.Instance is ArrayExtension, "#26");
 883
 884                         Assert.IsTrue (r.Read (), "#31");
 885                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 886                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33-2");
 887
 888                         Assert.IsTrue (r.Read (), "#41");
 889                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 890                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 891
 892                         Assert.IsTrue (r.Read (), "#51");
 893                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 894
 895                         Assert.IsTrue (r.Read (), "#61");
 896                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 897
 898                         Assert.IsFalse (r.Read (), "#71");
 899                         Assert.IsTrue (r.IsEof, "#72");
 900                 }
 901
 902                 [Test]
 903                 public void Read_DateTime ()
 904                 {
 905                         var obj = new DateTime (2010, 4, 15);
 906                         var r = new XamlObjectReader (obj);
 907                         Read_CommonClrType (r, obj);
 908                         Assert.AreEqual ("2010-04-15", Read_Initialization (r, null), "#1");
 909                 }
 910
 911                 [Test]
 912                 public void Read_TimeSpan ()
 913                 {
 914                         Read_CommonXamlPrimitive (TimeSpan.FromMinutes (4));
 915                 }
 916
 917                 [Test]
 918                 public void Read_Uri ()
 919                 {
 920                         Read_CommonXamlPrimitive (new Uri ("urn:foo"));
 921                 }
 922
 923                 [Test]
 924                 public void Read_Guid ()
 925                 {
 926                         var obj = Guid.NewGuid ();
 927                         var r = new XamlObjectReader (obj);
 928                         Assert.IsNotNull (r.SchemaContext.GetXamlType (typeof (Guid)).TypeConverter, "premise#1");
 929                         Read_CommonClrType (r, obj);
 930                         Assert.AreEqual (obj.ToString (), Read_Initialization (r, null), "#1");
 931                 }
 932
 933                 [Test]
 934                 [ExpectedException (typeof (XamlObjectReaderException))]
 935                 [Category ("NotWorking")]
 936                 public void Read_XData ()
 937                 {
 938                         var r = new XamlObjectReader (new XData () {Text = "xdata text"}); // XmlReader implementation is not visible.
 939                         while (!r.IsEof)
 940                                 r.Read ();
 941                 }
 942
 943                 [Test]
 944                 public void ReadStandardTypes ()
 945                 {
 946                         SimpleReadStandardType (new ArrayExtension ());
 947                         SimpleReadStandardType (new NullExtension ());
 948                         SimpleReadStandardType (new PropertyDefinition ());
 949                         SimpleReadStandardType (new Reference ());
 950                         SimpleReadStandardType (new StaticExtension ());
 951                         SimpleReadStandardType (new TypeExtension ());
 952                 }
 953
 954                 [Test]
 955                 public void Read_CustomMarkupExtension ()
 956                 {
 957                         var r = new XamlObjectReader (new MyExtension () { Foo = typeof (int), Bar = "v2", Baz = "v7"});
 958                         r.Read (); // ns
 959                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 960                         r.Read (); // ns
 961                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-2");
 962                         r.Read ();
 963                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
 964                         Assert.IsFalse (r.IsEof, "#1");
 965                         var xt = r.Type;
 966
 967                         r.Read ();
 968                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#2-1");
 969                         Assert.IsFalse (r.IsEof, "#2-2");
 970                         Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#2-3");
 971
 972                         Assert.IsTrue (r.Read (), "#2-4");
 973                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#2-5");
 974                         Assert.AreEqual ("v2", r.Value, "#2-6");
 975
 976                         Assert.IsTrue (r.Read (), "#2-7");
 977                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#2-8");
 978
 979                         r.Read ();
 980                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-1");
 981                         Assert.IsFalse (r.IsEof, "#3-2");
 982                         Assert.AreEqual (xt.GetMember ("Baz"), r.Member, "#3-3");
 983
 984                         Assert.IsTrue (r.Read (), "#3-4");
 985                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#3-5");
 986                         Assert.AreEqual ("v7", r.Value, "#3-6");
 987
 988                         Assert.IsTrue (r.Read (), "#3-7");
 989                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#3-8");
 990
 991                         r.Read ();
 992                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#4-1");
 993                         Assert.IsFalse (r.IsEof, "#4-2");
 994                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4-3");
 995                         Assert.IsTrue (r.Read (), "#4-4");
 996                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#4-5");
 997                         Assert.AreEqual ("x:Int32", r.Value, "#4-6");
 998
 999                         Assert.IsTrue (r.Read (), "#4-7");
1000                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#4-8");
1001
1002                         Assert.IsTrue (r.Read (), "#5");
1003                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#5-2");
1004
1005                         Assert.IsFalse (r.Read (), "#6");
1006                 }
1007
1008                 [Test]
1009                 public void Read_CustomMarkupExtension2 ()
1010                 {
1011                         var r = new XamlObjectReader (new MyExtension2 () { Foo = typeof (int), Bar = "v2"});
1012                         r.Read (); // ns
1013                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1014                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1015                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1016                         var xt = r.Type;
1017                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension2)), xt, "#2");
1018                         Assert.IsTrue (r.Read (), "#3");
1019                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1020                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1021                         Assert.IsTrue (r.Read (), "#5");
1022                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension2", r.Value, "#6");
1023                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1024                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1025                         Assert.IsFalse (r.Read (), "#9");
1026                 }
1027
1028                 [Test]
1029                 public void Read_CustomMarkupExtension3 ()
1030                 {
1031                         var r = new XamlObjectReader (new MyExtension3 () { Foo = typeof (int), Bar = "v2"});
1032                         r.Read (); // ns
1033                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1034                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1035                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1036                         var xt = r.Type;
1037                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension3)), xt, "#2");
1038                         Assert.IsTrue (r.Read (), "#3");
1039                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1040                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1041                         Assert.IsTrue (r.Read (), "#5");
1042                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension3", r.Value, "#6");
1043                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1044                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1045                         Assert.IsFalse (r.Read (), "#9");
1046                 }
1047
1048                 [Test]
1049                 public void Read_CustomMarkupExtension4 ()
1050                 {
1051                         var r = new XamlObjectReader (new MyExtension4 () { Foo = typeof (int), Bar = "v2"});
1052                         r.Read (); // ns
1053                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1054                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1055                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1056                         var xt = r.Type;
1057                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension4)), xt, "#2");
1058                         Assert.IsTrue (r.Read (), "#3");
1059                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1060                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
1061                         Assert.IsTrue (r.Read (), "#5");
1062                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension4", r.Value, "#6");
1063                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1064                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1065                         Assert.IsFalse (r.Read (), "#9");
1066                 }
1067
1068                 [Test]
1069                 [Category ("NotWorking")]
1070                 public void Read_CustomMarkupExtension5 ()
1071                 {
1072                         // This cannot be written to XamlXmlWriter though...
1073
1074                         var r = new XamlObjectReader (new MyExtension5 ("foo", "bar"));
1075                         r.Read (); // ns
1076                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1077                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1078                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1079                         var xt = r.Type;
1080                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension5)), xt, "#2");
1081                         Assert.IsTrue (r.Read (), "#3");
1082                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1083                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#4");
1084                         Assert.IsTrue (r.Read (), "#5");
1085                         Assert.AreEqual ("foo", r.Value, "#6");
1086                         Assert.IsTrue (r.Read (), "#7");
1087                         Assert.AreEqual ("bar", r.Value, "#8");
1088                         Assert.IsTrue (r.Read (), "#9");
1089                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#10");
1090                         Assert.IsTrue (r.Read (), "#11");
1091                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#12");
1092                         Assert.IsFalse (r.Read (), "#13");
1093                 }
1094
1095                 [Test]
1096                 [Category ("NotWorking")]
1097                 public void Read_CustomMarkupExtension6 ()
1098                 {
1099                         var r = new XamlObjectReader (new MyExtension6 ("foo"));
1100                         r.Read (); // ns
1101                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
1102                         r.Read (); // note that there wasn't another NamespaceDeclaration.
1103                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0");
1104                         var xt = r.Type;
1105                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension6)), xt, "#2");
1106                         Assert.IsTrue (r.Read (), "#3");
1107                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-2");
1108                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4"); // this is the difference between MyExtension5 and MyExtension6: it outputs constructor arguments as normal members
1109                         Assert.IsTrue (r.Read (), "#5");
1110                         Assert.AreEqual ("foo", r.Value, "#6");
1111                         Assert.IsTrue (r.Read (), "#7"); // EndMember
1112                         Assert.IsTrue (r.Read (), "#8"); // EndObject
1113                         Assert.IsFalse (r.Read (), "#9");
1114                 }
1115
1116                 [Test]
1117                 public void Read_ArgumentAttributed ()
1118                 {
1119                         var obj = new ArgumentAttributed ("foo", "bar");
1120                         var r = new XamlObjectReader (obj);
1121                         Read_CommonClrType (r, obj, new KeyValuePair<string,string> ("x", XamlLanguage.Xaml2006Namespace));
1122                         var args = Read_AttributedArguments_String (r, new string [] {"arg1", "arg2"});
1123                         Assert.AreEqual ("foo", args [0], "#1");
1124                         Assert.AreEqual ("bar", args [1], "#2");
1125                 }
1126
1127                 [Test]
1128                 public void Read_Dictionary ()
1129                 {
1130                         var obj = new Dictionary<string,object> ();
1131                         obj ["Foo"] = 5.0;
1132                         obj ["Bar"] = -6.5;
1133                         var r = new XamlObjectReader (obj);
1134
1135                         Assert.IsTrue (r.Read (), "ns#1-1");
1136                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1137                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1138                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1139                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "ns#1-5");
1140
1141                         Assert.IsTrue (r.Read (), "ns#2-1");
1142                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1143                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1144                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1145                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1146
1147                         Assert.IsTrue (r.Read (), "so#1-1");
1148                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1149                         var xt = new XamlType (typeof (Dictionary<string,object>), r.SchemaContext);
1150                         Assert.AreEqual (xt, r.Type, "so#1-3");
1151                         Assert.AreEqual (obj, r.Instance, "so#1-4");
1152
1153                         Assert.IsTrue (r.Read (), "smitems#1");
1154                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smitems#2");
1155                         Assert.AreEqual (XamlLanguage.Items, r.Member, "smitems#3");
1156
1157                         for (int i = 0; i < 2; i++) {
1158
1159                                 // start of an item
1160                                 Assert.IsTrue (r.Read (), "soi#1-1." + i);
1161                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "soi#1-2." + i);
1162                                 var xt2 = new XamlType (typeof (double), r.SchemaContext);
1163                                 Assert.AreEqual (xt2, r.Type, "soi#1-3." + i);
1164
1165                                 Assert.IsTrue (r.Read (), "smi#1-1." + i);
1166                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#1-2." + i);
1167                                 Assert.AreEqual (XamlLanguage.Key, r.Member, "smi#1-3." + i);
1168
1169                                 Assert.IsTrue (r.Read (), "svi#1-1." + i);
1170                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#1-2." + i);
1171                                 Assert.AreEqual (i == 0 ? "Foo" : "Bar", r.Value, "svi#1-3." + i);
1172
1173                                 Assert.IsTrue (r.Read (), "emi#1-1." + i);
1174                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#1-2." + i);
1175
1176                                 Assert.IsTrue (r.Read (), "smi#2-1." + i);
1177                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "smi#2-2." + i);
1178                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, "smi#2-3." + i);
1179
1180                                 Assert.IsTrue (r.Read (), "svi#2-1." + i);
1181                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "svi#2-2." + i);
1182                                 Assert.AreEqual (i == 0 ? "5" : "-6.5", r.Value, "svi#2-3." + i); // converted to string(!)
1183
1184                                 Assert.IsTrue (r.Read (), "emi#2-1." + i);
1185                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emi#2-2." + i);
1186
1187                                 Assert.IsTrue (r.Read (), "eoi#1-1." + i);
1188                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eoi#1-2." + i);
1189                                 // end of an item
1190                         }
1191
1192                         Assert.IsTrue (r.Read (), "emitems#1");
1193                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "emitems#2"); // XamlLanguage.Items
1194
1195                         Assert.IsTrue (r.Read (), "eo#1-1");
1196                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2"); // Dictionary
1197
1198                         Assert.IsFalse (r.Read (), "end");
1199                 }
1200
1201                 [Test]
1202                 [Category ("NotWorking")]
1203                 public void PositionalParameters1 ()
1204                 {
1205                         // ns1 > T:PositionalParametersClass1 > M:_PositionalParameters > foo > 5 > EM:_PositionalParameters > ET:PositionalParametersClass1
1206
1207                         // Note: this can be read, but cannot be written to XML.
1208                         var obj = new PositionalParametersClass1 ("foo", 5);
1209                         var r = new XamlObjectReader (obj);
1210
1211                         Assert.IsTrue (r.Read (), "ns#1-1");
1212                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1213                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1214                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1215                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1216
1217                         Assert.IsTrue (r.Read (), "so#1-1");
1218                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1219                         var xt = new XamlType (typeof (PositionalParametersClass1), r.SchemaContext);
1220                         Assert.AreEqual (xt, r.Type, "so#1-3");
1221                         Assert.AreEqual (obj, r.Instance, "so#1-4");
1222
1223                         Assert.IsTrue (r.Read (), "sposprm#1");
1224                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1225                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "sposprm#3");
1226
1227                         Assert.IsTrue (r.Read (), "sva#1-1");
1228                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1229                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1230
1231                         Assert.IsTrue (r.Read (), "sva#2-1");
1232                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#2-2");
1233                         Assert.AreEqual ("5", r.Value, "sva#2-3");
1234
1235                         Assert.IsTrue (r.Read (), "eposprm#1");
1236                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2"); // XamlLanguage.PositionalParameters
1237
1238                         Assert.IsTrue (r.Read (), "eo#1-1");
1239                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1240
1241                         Assert.IsFalse (r.Read (), "end");
1242                 }
1243
1244                 [Test]
1245                 [Category ("NotWorking")]
1246                 public void PositionalParameters2 ()
1247                 {
1248                         // ns1 > T:PositionalParametersWrapper > M:Body > T:PositionalParametersClass1 > M:_PositionalParameters > foo > 5 > EM:_PositionalParameters > ET:PositionalParametersClass1
1249
1250                         var obj = new PositionalParametersWrapper ("foo", 5);
1251                         var r = new XamlObjectReader (obj);
1252
1253                         Assert.IsTrue (r.Read (), "ns#1-1");
1254                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1255                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1256                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1257                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1258
1259                         Assert.IsTrue (r.Read (), "so#1-1");
1260                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1261                         var xt = new XamlType (typeof (PositionalParametersWrapper), r.SchemaContext);
1262                         Assert.AreEqual (xt, r.Type, "so#1-3");
1263                         Assert.AreEqual (obj, r.Instance, "so#1-4");
1264
1265                         Assert.IsTrue (r.Read (), "sm#1-1");
1266                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#1-2");
1267                         Assert.AreEqual (xt.GetMember ("Body"), r.Member, "sm#1-3");
1268
1269                         xt = new XamlType (typeof (PositionalParametersClass1), r.SchemaContext);
1270                         Assert.IsTrue (r.Read (), "so#2-1");
1271                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1272                         Assert.AreEqual (xt, r.Type, "so#2-3");
1273                         Assert.AreEqual (obj.Body, r.Instance, "so#2-4");
1274
1275                         Assert.IsTrue (r.Read (), "sposprm#1");
1276                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sposprm#2");
1277                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "sposprm#3");
1278
1279                         Assert.IsTrue (r.Read (), "sva#1-1");
1280                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#1-2");
1281                         Assert.AreEqual ("foo", r.Value, "sva#1-3");
1282
1283                         Assert.IsTrue (r.Read (), "sva#2-1");
1284                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "sva#2-2");
1285                         Assert.AreEqual ("5", r.Value, "sva#2-3");
1286
1287                         Assert.IsTrue (r.Read (), "eposprm#1");
1288                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eposprm#2"); // XamlLanguage.PositionalParameters
1289
1290                         Assert.IsTrue (r.Read (), "eo#2-1");
1291                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1292
1293                         Assert.IsTrue (r.Read (), "em#1-1");
1294                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eo#1-2");
1295
1296                         Assert.IsTrue (r.Read (), "eo#1-1");
1297                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1298
1299                         Assert.IsFalse (r.Read (), "end");
1300                 }
1301
1302                 [Test]
1303                 [Category ("NotWorking")]
1304                 public void ComplexPositionalParameters ()
1305                 {
1306                         var obj = new ComplexPositionalParameterWrapper () { Param = new ComplexPositionalParameterClass (new ComplexPositionalParameterValue () { Foo = "foo" })};
1307                         var r = new XamlObjectReader (obj);
1308
1309                         Assert.IsTrue (r.Read (), "ns#1-1");
1310                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2");
1311                         Assert.IsNotNull (r.Namespace, "ns#1-3");
1312                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-4");
1313                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ns#1-5");
1314
1315                         Assert.IsTrue (r.Read (), "ns#2-1");
1316                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2");
1317                         Assert.IsNotNull (r.Namespace, "ns#2-3");
1318                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns#2-4");
1319                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#2-5");
1320
1321                         Assert.IsTrue (r.Read (), "so#1-1");
1322                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#1-2");
1323                         var xt = new XamlType (obj.GetType (), r.SchemaContext);
1324                         Assert.AreEqual (xt, r.Type, "so#1-3");
1325                         Assert.AreEqual (obj, r.Instance, "so#1-4");
1326
1327                         Assert.IsTrue (r.Read (), "sm#1-1");
1328                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#1-2");
1329                         Assert.AreEqual (xt.GetMember ("Param"), r.Member, "sm#1-3");
1330
1331                         xt = r.SchemaContext.GetXamlType (typeof (ComplexPositionalParameterClass));
1332                         Assert.IsTrue (r.Read (), "so#2-1");
1333                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2-2");
1334                         Assert.AreEqual (xt, r.Type, "so#2-3");
1335                         Assert.AreEqual (obj.Param, r.Instance, "so#2-4");
1336
1337                         Assert.IsTrue (r.Read (), "sarg#1");
1338                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sarg#2");
1339                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "sarg#3");
1340
1341                         Assert.IsTrue (r.Read (), "so#3-1");
1342                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#3-2");
1343                         xt = r.SchemaContext.GetXamlType (typeof (ComplexPositionalParameterValue));
1344                         Assert.AreEqual (xt, r.Type, "so#3-3");
1345
1346                         Assert.IsTrue (r.Read (), "sm#3-1");
1347                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sm#3-2");
1348                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "sm#3-3");
1349                         Assert.IsTrue (r.Read (), "v#3-1");
1350                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "v#3-2");
1351                         Assert.AreEqual ("foo", r.Value, "v#3-3");
1352
1353                         Assert.IsTrue (r.Read (), "em#3-1");
1354                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "em#3-2");
1355                         Assert.IsTrue (r.Read (), "eo#3-1");
1356                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#3-2");
1357
1358                         Assert.IsTrue (r.Read (), "earg#1");
1359                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "earg#2"); // XamlLanguage.Arguments
1360
1361                         Assert.IsTrue (r.Read (), "eo#2-1");
1362                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2-2");
1363
1364                         Assert.IsTrue (r.Read (), "em#1-1");
1365                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eo#1-2");
1366
1367                         Assert.IsTrue (r.Read (), "eo#1-1");
1368                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#1-2");
1369
1370                         Assert.IsFalse (r.Read (), "end");
1371                 }
1372
1373                 [Test]
1374                 [Category ("NotWorking")]
1375                 public void Read_ListWrapper ()
1376                 {
1377                         var obj = new ListWrapper (new List<int> (new int [] {5, -3, 0}));
1378                         var r = new XamlObjectReader (obj);
1379
1380                         Assert.IsTrue (r.Read (), "#1");
1381                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
1382                         Assert.IsNotNull (r.Namespace, "#3");
1383                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
1384
1385                         Assert.IsTrue (r.Read (), "#11");
1386                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
1387                         Assert.IsNotNull (r.Namespace, "#13");
1388                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
1389                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
1390
1391                         Assert.IsTrue (r.Read (), "#21");
1392                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
1393                         var xt = new XamlType (obj.GetType (), r.SchemaContext);
1394                         Assert.AreEqual (xt, r.Type, "#23");
1395                         Assert.AreEqual (obj, r.Instance, "#26");
1396
1397                         Assert.IsTrue (r.Read (), "#61");
1398                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
1399                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
1400
1401                         Assert.IsTrue (r.Read (), "#71");
1402                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
1403                         Assert.IsNull (r.Type, "#71-3");
1404                         Assert.IsNull (r.Member, "#71-4");
1405                         Assert.IsNull (r.Value, "#71-5");
1406
1407                         Assert.IsTrue (r.Read (), "#72");
1408                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
1409                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
1410
1411                         string [] values = {"5", "-3", "0"};
1412                         for (int i = 0; i < 3; i++) {
1413                                 Assert.IsTrue (r.Read (), i + "#73");
1414                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
1415                                 Assert.IsTrue (r.Read (), i + "#74");
1416                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
1417                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
1418                                 Assert.IsTrue (r.Read (), i + "#75");
1419                                 Assert.IsNotNull (r.Value, i + "#75-2");
1420                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
1421                                 Assert.IsTrue (r.Read (), i + "#74");
1422                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
1423                                 Assert.IsTrue (r.Read (), i + "#75");
1424                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
1425                         }
1426
1427                         Assert.IsTrue (r.Read (), "#81");
1428                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
1429
1430                         Assert.IsTrue (r.Read (), "#83");
1431                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
1432
1433                         Assert.IsTrue (r.Read (), "#85");
1434                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ListWrapper.Items
1435
1436                         Assert.IsTrue (r.Read (), "#87");
1437                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ListWrapper
1438
1439                         Assert.IsFalse (r.Read (), "#89");
1440                 }
1441
1442                 [Test]
1443                 [Category ("NotWorking")]
1444                 public void Read_ListWrapper2 () // read-write list member.
1445                 {
1446                         var obj = new ListWrapper2 (new List<int> (new int [] {5, -3, 0}));
1447                         var r = new XamlObjectReader (obj);
1448
1449                         Assert.IsTrue (r.Read (), "#1");
1450                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2");
1451                         Assert.IsNotNull (r.Namespace, "#3");
1452                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2");
1453
1454                         Assert.IsTrue (r.Read (), "#6");
1455                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
1456                         Assert.IsNotNull (r.Namespace, "#8");
1457                         Assert.AreEqual ("scg", r.Namespace.Prefix, "#8-2");
1458                         Assert.AreEqual ("clr-namespace:System.Collections.Generic;assembly=mscorlib", r.Namespace.Namespace, "#8-3");
1459
1460                         Assert.IsTrue (r.Read (), "#11");
1461                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
1462                         Assert.IsNotNull (r.Namespace, "#13");
1463                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
1464                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
1465
1466                         Assert.IsTrue (r.Read (), "#21");
1467                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
1468                         var xt = new XamlType (obj.GetType (), r.SchemaContext);
1469                         Assert.AreEqual (xt, r.Type, "#23");
1470                         Assert.AreEqual (obj, r.Instance, "#26");
1471
1472                         Assert.IsTrue (r.Read (), "#61");
1473                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
1474                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
1475
1476                         Assert.IsTrue (r.Read (), "#71");
1477                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#71-2");
1478                         xt = r.SchemaContext.GetXamlType (typeof (List<int>));
1479                         Assert.AreEqual (xt, r.Type, "#71-3");
1480                         Assert.IsNull (r.Member, "#71-4");
1481                         Assert.IsNull (r.Value, "#71-5");
1482
1483                         // Capacity
1484                         Assert.IsTrue (r.Read (), "#31");
1485                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
1486                         Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33");
1487
1488                         Assert.IsTrue (r.Read (), "#41");
1489                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
1490                         // The value is implementation details, not testable.
1491                         //Assert.AreEqual ("3", r.Value, "#43");
1492
1493                         Assert.IsTrue (r.Read (), "#51");
1494                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
1495
1496                         // Items
1497                         Assert.IsTrue (r.Read (), "#72");
1498                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
1499                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
1500
1501                         string [] values = {"5", "-3", "0"};
1502                         for (int i = 0; i < 3; i++) {
1503                                 Assert.IsTrue (r.Read (), i + "#73");
1504                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
1505                                 Assert.IsTrue (r.Read (), i + "#74");
1506                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
1507                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
1508                                 Assert.IsTrue (r.Read (), i + "#75");
1509                                 Assert.IsNotNull (r.Value, i + "#75-2");
1510                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
1511                                 Assert.IsTrue (r.Read (), i + "#74");
1512                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
1513                                 Assert.IsTrue (r.Read (), i + "#75");
1514                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
1515                         }
1516
1517                         Assert.IsTrue (r.Read (), "#81");
1518                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
1519
1520                         Assert.IsTrue (r.Read (), "#83");
1521                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // StartObject(of List<int>)
1522
1523                         Assert.IsTrue (r.Read (), "#85");
1524                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ListWrapper.Items
1525
1526                         Assert.IsTrue (r.Read (), "#87");
1527                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ListWrapper
1528
1529                         Assert.IsFalse (r.Read (), "#89");
1530                 }
1531
1532                 void SimpleReadStandardType (object instance)
1533                 {
1534                         var r = new XamlObjectReader (instance);
1535                         while (!r.IsEof)
1536                                 r.Read ();
1537                 }
1538
1539                 void Read_CommonXamlPrimitive (object obj)
1540                 {
1541                         var r = new XamlObjectReader (obj);
1542                         Read_CommonXamlType (r);
1543                         Read_Initialization (r, obj);
1544                 }
1545
1546                 // from StartMember of Initialization to EndMember
1547                 string Read_Initialization (XamlObjectReader r, object comparableValue)
1548                 {
1549                         Assert.IsTrue (r.Read (), "init#1");
1550                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "init#2");
1551                         Assert.IsNotNull (r.Member, "init#3");
1552                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "init#3-2");
1553                         Assert.IsTrue (r.Read (), "init#4");
1554                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "init#5");
1555                         Assert.AreEqual (typeof (string), r.Value.GetType (), "init#6");
1556                         string ret = (string) r.Value;
1557                         if (comparableValue != null)
1558                                 Assert.AreEqual (comparableValue.ToString (), r.Value, "init#6-2");
1559                         Assert.IsTrue (r.Read (), "init#7");
1560                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "init#8");
1561                         return ret;
1562                 }
1563
1564                 object [] Read_AttributedArguments_String (XamlObjectReader r, string [] argNames) // valid only for string arguments.
1565                 {
1566                         object [] ret = new object [argNames.Length];
1567
1568                         Assert.IsTrue (r.Read (), "attarg.Arguments.Start1");
1569                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.Arguments.Start2");
1570                         Assert.IsNotNull (r.Member, "attarg.Arguments.Start3");
1571                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "attarg.Arguments.Start4");
1572                         for (int i = 0; i < argNames.Length; i++) {
1573                                 string arg = argNames [i];
1574                                 Assert.IsTrue (r.Read (), "attarg.ArgStartObject1." + arg);
1575                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "attarg.ArgStartObject2." + arg);
1576                                 Assert.AreEqual (typeof (string), r.Type.UnderlyingType, "attarg.ArgStartObject3." + arg);
1577                                 Assert.IsTrue (r.Read (), "attarg.ArgStartMember1." + arg);
1578                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.ArgStartMember2." + arg);
1579                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, "attarg.ArgStartMember3." + arg); // (as the argument is string here by definition)
1580                                 Assert.IsTrue (r.Read (), "attarg.ArgValue1." + arg);
1581                                 Assert.AreEqual (XamlNodeType.Value, r.NodeType, "attarg.ArgValue2." + arg);
1582                                 Assert.AreEqual (typeof (string), r.Value.GetType (), "attarg.ArgValue3." + arg);
1583                                 ret [i] = r.Value;
1584                                 Assert.IsTrue (r.Read (), "attarg.ArgEndMember1." + arg);
1585                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.ArgEndMember2." + arg);
1586                                 Assert.IsTrue (r.Read (), "attarg.ArgEndObject1." + arg);
1587                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "attarg.ArgEndObject2." + arg);
1588                         }
1589                         Assert.IsTrue (r.Read (), "attarg.Arguments.End1");
1590                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.Arguments.End2");
1591                         return ret;
1592                 }
1593
1594                 // from initial to StartObject
1595                 void Read_CommonXamlType (XamlObjectReader r)
1596                 {
1597                         Assert.IsTrue (r.Read (), "ct#1");
1598                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
1599                         Assert.IsNotNull (r.Namespace, "ct#3");
1600                         Assert.AreEqual ("x", r.Namespace.Prefix, "ct#3-2");
1601                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ct#3-3");
1602                         Assert.IsNull (r.Instance, "ct#4");
1603
1604                         Assert.IsTrue (r.Read (), "ct#5");
1605                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#6");
1606                 }
1607
1608                 // from initial to StartObject
1609                 void Read_CommonClrType (XamlObjectReader r, object obj, params KeyValuePair<string,string> [] additionalNamespaces)
1610                 {
1611                         Assert.IsTrue (r.Read (), "ct#1");
1612                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
1613                         Assert.IsNotNull (r.Namespace, "ct#3");
1614                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ct#3-2");
1615                         Assert.AreEqual ("clr-namespace:" + obj.GetType ().Namespace + ";assembly=" + obj.GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ct#3-3");
1616
1617                         foreach (var kvp in additionalNamespaces) {
1618                                 Assert.IsTrue (r.Read (), "ct#4." + kvp.Key);
1619                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#5." + kvp.Key);
1620                                 Assert.IsNotNull (r.Namespace, "ct#6." + kvp.Key);
1621                                 Assert.AreEqual (kvp.Key, r.Namespace.Prefix, "ct#6-2." + kvp.Key);
1622                                 Assert.AreEqual (kvp.Value, r.Namespace.Namespace, "ct#6-3." + kvp.Key);
1623                         }
1624
1625                         Assert.IsTrue (r.Read (), "ct#7");
1626                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#8");
1627                 }
1628         }
1629
1630         class TestClass1
1631         {
1632         }
1633
1634         public class TestClass3
1635         {
1636                 public TestClass3 Nested { get; set; }
1637         }
1638
1639         public class TestClass4
1640         {
1641                 public string Foo { get; set; }
1642                 public string Bar { get; set; }
1643         }
1644
1645         public class TestClass5
1646         {
1647                 public static string Foo { get; set; }
1648                 public string Bar { get; set; }
1649                 public string Baz { internal get; set; }
1650                 public string ReadOnly {
1651                         get { return Foo; }
1652                 }
1653         }
1654
1655         public class MyExtension : MarkupExtension
1656         {
1657                 public MyExtension ()
1658                 {
1659                 }
1660
1661                 public MyExtension (Type arg1, string arg2, string arg3)
1662                 {
1663                         Foo = arg1;
1664                         Bar = arg2;
1665                         Baz = arg3;
1666                 }
1667
1668                 [ConstructorArgument ("arg1")]
1669                 public Type Foo { get; set; }
1670
1671                 [ConstructorArgument ("arg2")]
1672                 public string Bar { get; set; }
1673
1674                 [ConstructorArgument ("arg3")]
1675                 public string Baz { get; set; }
1676
1677                 public override object ProvideValue (IServiceProvider provider)
1678                 {
1679                         return "provided_value";
1680                 }
1681         }
1682
1683         [TypeConverter (typeof (StringConverter))] // This attribute is the markable difference between MyExtension and this type.
1684         public class MyExtension2 : MarkupExtension
1685         {
1686                 public MyExtension2 ()
1687                 {
1688                 }
1689
1690                 public MyExtension2 (Type arg1, string arg2)
1691                 {
1692                         Foo = arg1;
1693                         Bar = arg2;
1694                 }
1695
1696                 [ConstructorArgument ("arg1")]
1697                 public Type Foo { get; set; }
1698
1699                 [ConstructorArgument ("arg2")]
1700                 public string Bar { get; set; }
1701
1702                 public override object ProvideValue (IServiceProvider provider)
1703                 {
1704                         return "provided_value";
1705                 }
1706         }
1707
1708         [TypeConverter (typeof (StringConverter))] // same as MyExtension2 except that it is *not* MarkupExtension.
1709         public class MyExtension3
1710         {
1711                 public MyExtension3 ()
1712                 {
1713                 }
1714
1715                 // cf. According to [MS-XAML-2009] 3.2.1.11, constructors are invalid unless the type is derived from TypeExtension. So, it is likely *ignored*.
1716                 public MyExtension3 (Type arg1, string arg2)
1717                 {
1718                         Foo = arg1;
1719                         Bar = arg2;
1720                 }
1721
1722                 [ConstructorArgument ("arg1")]
1723                 public Type Foo { get; set; }
1724
1725                 [ConstructorArgument ("arg2")]
1726                 public string Bar { get; set; }
1727         }
1728
1729         [TypeConverter (typeof (DateTimeConverter))] // same as MyExtension3 except for the type converter.
1730         public class MyExtension4
1731         {
1732                 public MyExtension4 ()
1733                 {
1734                 }
1735
1736                 // cf. According to [MS-XAML-2009] 3.2.1.11, constructors are invalid unless the type is derived from TypeExtension. So, it is likely *ignored*.
1737                 public MyExtension4 (Type arg1, string arg2)
1738                 {
1739                         Foo = arg1;
1740                         Bar = arg2;
1741                 }
1742
1743                 [ConstructorArgument ("arg1")]
1744                 public Type Foo { get; set; }
1745
1746                 [ConstructorArgument ("arg2")]
1747                 public string Bar { get; set; }
1748         }
1749
1750         // no type converter, and there are only simple-type arguments == _PositionalParameters is applicable. (Unlike MyExtension7)
1751         public class MyExtension5 : MarkupExtension
1752         {
1753                 public MyExtension5 (string arg1, string arg2)
1754                 {
1755                         Foo = arg1;
1756                         Bar = arg2;
1757                 }
1758
1759                 [ConstructorArgument ("arg1")]
1760                 public string Foo { get; set; }
1761
1762                 [ConstructorArgument ("arg2")]
1763                 public string Bar { get; set; }
1764
1765                 public override object ProvideValue (IServiceProvider sp)
1766                 {
1767                         return Foo;
1768                 }
1769         }
1770
1771         // Almost the same as MyExtension5, BUT there is default constructor which XamlObjectReader prefers.
1772         public class MyExtension6 : MarkupExtension
1773         {
1774                 public MyExtension6 ()
1775                 {
1776                 }
1777
1778                 public MyExtension6 (string arg1)
1779                 {
1780                         Foo = arg1;
1781                 }
1782
1783                 [ConstructorArgument ("arg1")]
1784                 public string Foo { get; set; }
1785
1786                 public override object ProvideValue (IServiceProvider sp)
1787                 {
1788                         return Foo;
1789                 }
1790         }
1791
1792         public class PositionalParametersClass1 : MarkupExtension
1793         {
1794                 public PositionalParametersClass1 (string foo)
1795                         : this (foo, -1)
1796                 {
1797                 }
1798
1799                 public PositionalParametersClass1 (string foo, int bar)
1800                 {
1801                         Foo = foo;
1802                         Bar = bar;
1803                 }
1804
1805                 [ConstructorArgument ("foo")]
1806                 public string Foo { get; set; }
1807
1808                 [ConstructorArgument ("bar")]
1809                 public int Bar { get; set; }
1810
1811                 public override object ProvideValue (IServiceProvider sp)
1812                 {
1813                         return Foo;
1814                 }
1815         }
1816
1817         public class PositionalParametersWrapper
1818         {
1819                 public PositionalParametersClass1 Body { get; set; }
1820
1821                 public PositionalParametersWrapper ()
1822                 {
1823                 }
1824
1825                 public PositionalParametersWrapper (string foo, int bar)
1826                 {
1827                         Body = new PositionalParametersClass1 (foo, bar);
1828                 }
1829         }
1830
1831         public class ListWrapper
1832         {
1833                 public ListWrapper ()
1834                 {
1835                         Items = new List<int> ();
1836                 }
1837
1838                 public ListWrapper (List<int> items)
1839                 {
1840                         Items = items;
1841                 }
1842
1843                 public List<int> Items { get; private set; }
1844         }
1845
1846         public class ListWrapper2
1847         {
1848                 public ListWrapper2 ()
1849                 {
1850                         Items = new List<int> ();
1851                 }
1852
1853                 public ListWrapper2 (List<int> items)
1854                 {
1855                         Items = items;
1856                 }
1857
1858                 public List<int> Items { get; set; } // it is settable, which makes difference.
1859         }
1860 }