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 Category = 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 Skip ()
 180                 {
 181                         var r = new XamlObjectReader ("Foo");
 182                         r.Skip ();
 183                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 184                         r.Skip ();
 185                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2");
 186                         r.Skip ();
 187                         Assert.IsTrue (r.IsEof, "#3");
 188                 }
 189
 190                 [Test]
 191                 public void Skip2 ()
 192                 {
 193                         var r = new XamlObjectReader ("Foo");
 194                         r.Read (); // NamespaceDeclaration
 195                         r.Read (); // Type
 196                         r.Read (); // Member (Initialization)
 197                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#1");
 198                         r.Skip ();
 199                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#2");
 200                         r.Skip ();
 201                         Assert.IsTrue (r.IsEof, "#3");
 202                 }
 203
 204                 [Test]
 205                 [Category ("NotWorking")]
 206                 public void Read2 ()
 207                 {
 208                         var doc = new XmlDocument ();
 209                         doc.LoadXml ("<root xmlns='urn:foo'><elem attr='val' /></root>");
 210                         var r = new XamlObjectReader (doc);
 211
 212                         for (int i = 0; i < 3; i++) {
 213                                 r.Read ();
 214                                 Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-" + i);
 215                         }
 216                         r.Read ();
 217
 218                         Assert.AreEqual (new XamlType (typeof (XmlDocument), r.SchemaContext), r.Type, "#2");
 219                         r.Read ();
 220                         var l = new List<XamlMember> ();
 221                         for (int i = 0; i < 5; i++) {
 222                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-" + i);
 223                                 l.Add (r.Member);
 224                                 r.Skip ();
 225                         }
 226                         l.First (m => m.Name == "Value");
 227                         l.First (m => m.Name == "InnerXml");
 228                         l.First (m => m.Name == "Prefix");
 229                         l.First (m => m.Name == "PreserveWhitespace");
 230                         l.First (m => m.Name == "Schemas");
 231                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#4");
 232                         Assert.IsFalse (r.Read (), "#5");
 233                 }
 234
 235                 [Test]
 236                 public void Read_NonPrimitive ()
 237                 {
 238                         var r = new XamlObjectReader (new TestClass3 ());
 239                         Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1");
 240                         Assert.IsTrue (r.Read (), "#6");
 241                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7");
 242                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#7-2");
 243                         Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "#7-3");
 244
 245                         Assert.IsTrue (r.Read (), "#11");
 246                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 247                         Assert.AreEqual ("x", r.Namespace.Prefix, "#12-2");
 248                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#12-3");
 249
 250                         Assert.IsTrue (r.Read (), "#16");
 251                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#17");
 252                         var xt = new XamlType (typeof (TestClass3), r.SchemaContext);
 253                         Assert.AreEqual (xt, r.Type, "#17-2");
 254                         Assert.IsTrue (r.Instance is TestClass3, "#17-3");
 255
 256                         Assert.IsTrue (r.Read (), "#21");
 257                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#22");
 258                         Assert.AreEqual (xt.GetMember ("Nested"), r.Member, "#22-2");
 259
 260                         Assert.IsTrue (r.Read (), "#26");
 261                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#27");
 262                         Assert.AreEqual (XamlLanguage.Null, r.Type, "#27-2");
 263                         Assert.IsNull (r.Instance, "#27-3");
 264
 265                         Assert.IsTrue (r.Read (), "#31");
 266                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#32");
 267
 268                         Assert.IsTrue (r.Read (), "#36");
 269                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#37");
 270
 271                         Assert.IsTrue (r.Read (), "#41");
 272                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#42");
 273
 274                         Assert.IsFalse (r.Read (), "#46");
 275                         Assert.IsTrue (r.IsEof, "#47");
 276                 }
 277
 278                 [Test]
 279                 public void Read_Type ()
 280                 {
 281                         var r = new XamlObjectReader (typeof (int));
 282                         Read_TypeOrTypeExtension (r);
 283                 }
 284
 285                 [Test]
 286                 public void Read_TypeExtension ()
 287                 {
 288                         var r = new XamlObjectReader (new TypeExtension (typeof (int)));
 289                         Read_TypeOrTypeExtension (r);
 290                 }
 291
 292                 void Read_TypeOrTypeExtension (XamlObjectReader r)
 293                 {
 294                         Assert.IsTrue (r.Read (), "#11");
 295                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 296                         Assert.IsNotNull (r.Namespace, "#13");
 297                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 298                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 299                         Assert.IsNull (r.Instance, "#14");
 300
 301                         Assert.IsTrue (r.Read (), "#21");
 302                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 303                         Assert.IsNotNull (r.Type, "#23");
 304                         Assert.AreEqual (new XamlType (typeof (TypeExtension), r.SchemaContext), r.Type, "#23-2");
 305                         Assert.IsNull (r.Namespace, "#25");
 306                         Assert.IsTrue (r.Instance is TypeExtension, "#26");
 307
 308                         Assert.IsTrue (r.Read (), "#31");
 309                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 310                         Assert.IsNotNull (r.Member, "#33");
 311                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 312                         Assert.IsNull (r.Type, "#34");
 313                         Assert.IsNull (r.Instance, "#35");
 314
 315                         Assert.IsTrue (r.Read (), "#41");
 316                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 317                         Assert.IsNotNull (r.Value, "#43");
 318                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 319                         Assert.IsNull (r.Member, "#44");
 320                         Assert.IsNull (r.Instance, "#45");
 321
 322                         Assert.IsTrue (r.Read (), "#51");
 323                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 324                         Assert.IsNull (r.Type, "#53");
 325                         Assert.IsNull (r.Member, "#54");
 326                         Assert.IsNull (r.Instance, "#55");
 327
 328                         Assert.IsTrue (r.Read (), "#61");
 329                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 330                         Assert.IsNull (r.Type, "#63");
 331
 332                         Assert.IsFalse (r.Read (), "#71");
 333                         Assert.IsTrue (r.IsEof, "#72");
 334                 }
 335
 336                 [Test]
 337                 public void Read_Type2 ()
 338                 {
 339                         var r = new XamlObjectReader (typeof (TestClass1));
 340                         Read_TypeOrTypeExtension2 (r);
 341                 }
 342
 343                 [Test]
 344                 public void Read_TypeExtension2 ()
 345                 {
 346                         var r = new XamlObjectReader (new TypeExtension (typeof (TestClass1)));
 347                         Read_TypeOrTypeExtension2 (r);
 348                 }
 349
 350                 void Read_TypeOrTypeExtension2 (XamlObjectReader r)
 351                 {
 352                         Assert.IsTrue (r.Read (), "#11");
 353                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 354
 355                         var defns = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name;
 356
 357                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#13-2");
 358                         Assert.AreEqual (defns, r.Namespace.Namespace, "#13-3:" + r.Namespace.Prefix);
 359
 360                         Assert.IsTrue (r.Read (), "#16");
 361                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#17");
 362                         Assert.IsNotNull (r.Namespace, "#18");
 363                         Assert.AreEqual ("x", r.Namespace.Prefix, "#18-2");
 364                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#18-3:" + r.Namespace.Prefix);
 365
 366                         Assert.IsTrue (r.Read (), "#21");
 367                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 368                         Assert.AreEqual (new XamlType (typeof (TypeExtension), r.SchemaContext), r.Type, "#23-2");
 369                         Assert.IsTrue (r.Instance is TypeExtension, "#26");
 370
 371                         Assert.IsTrue (r.Read (), "#31");
 372                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 373                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 374
 375                         Assert.IsTrue (r.Read (), "#41");
 376                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 377                         Assert.AreEqual ("TestClass1", r.Value, "#43-2");
 378
 379                         Assert.IsTrue (r.Read (), "#51");
 380                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 381
 382                         Assert.IsTrue (r.Read (), "#61");
 383                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 384
 385                         Assert.IsFalse (r.Read (), "#71");
 386                         Assert.IsTrue (r.IsEof, "#72");
 387                 }
 388
 389                 [Test]
 390                 public void Read_Reference ()
 391                 {
 392                         var r = new XamlObjectReader (new Reference ("TestName"));
 393                         Assert.IsTrue (r.Read (), "#11");
 394                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 395                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 396                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 397
 398                         Assert.IsTrue (r.Read (), "#21");
 399                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 400                         var xt = new XamlType (typeof (Reference), r.SchemaContext);
 401                         Assert.AreEqual (xt, r.Type, "#23-2");
 402                         Assert.IsTrue (r.Instance is Reference, "#26");
 403
 404                         Assert.IsTrue (r.Read (), "#31");
 405                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 406                         // unlike TypeExtension there is no PositionalParameters.
 407                         Assert.AreEqual (xt.GetMember ("Name"), r.Member, "#33-2");
 408
 409                         // It is a ContentProperty (besides [ConstructorArgument])
 410                         Assert.IsTrue (r.Read (), "#41");
 411                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 412                         Assert.AreEqual ("TestName", r.Value, "#43-2");
 413
 414                         Assert.IsTrue (r.Read (), "#51");
 415                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 416
 417                         Assert.IsTrue (r.Read (), "#61");
 418                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 419
 420                         Assert.IsFalse (r.Read (), "#71");
 421                         Assert.IsTrue (r.IsEof, "#72");
 422                 }
 423
 424
 425                 [Test]
 426                 public void Read_Null ()
 427                 {
 428                         var r = new XamlObjectReader (null);
 429                         Read_NullOrNullExtension (r, null);
 430                 }
 431
 432                 [Test]
 433                 public void Read_NullExtension ()
 434                 {
 435                         var o = new NullExtension ();
 436                         var r = new XamlObjectReader (o);
 437                         Read_NullOrNullExtension (r, o);
 438                 }
 439
 440                 void Read_NullOrNullExtension (XamlObjectReader r, object instance)
 441                 {
 442                         Assert.IsTrue (r.Read (), "#11");
 443                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 444                         Assert.IsNotNull (r.Namespace, "#13");
 445                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 446                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 447                         Assert.IsNull (r.Instance, "#14");
 448
 449                         Assert.IsTrue (r.Read (), "#21");
 450                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 451                         Assert.AreEqual (new XamlType (typeof (NullExtension), r.SchemaContext), r.Type, "#23-2");
 452                         Assert.AreEqual (instance, r.Instance, "#26"); // null and NullExtension are different here.
 453
 454                         Assert.IsTrue (r.Read (), "#61");
 455                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 456
 457                         Assert.IsFalse (r.Read (), "#71");
 458                         Assert.IsTrue (r.IsEof, "#72");
 459                 }
 460
 461                 [Test] // almost identical to TypeExtension (only type/instance difference)
 462                 [Category ("NotWorking")]
 463                 public void Read_StaticExtension ()
 464                 {
 465                         var r = new XamlObjectReader (new StaticExtension ("MyMember"));
 466                         Assert.IsTrue (r.Read (), "#11");
 467                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 468                         Assert.IsNotNull (r.Namespace, "#13");
 469                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 470                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 471                         Assert.IsNull (r.Instance, "#14");
 472
 473                         Assert.IsTrue (r.Read (), "#21");
 474                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 475                         Assert.AreEqual (new XamlType (typeof (StaticExtension), r.SchemaContext), r.Type, "#23-2");
 476                         Assert.IsTrue (r.Instance is StaticExtension, "#26");
 477
 478                         Assert.IsTrue (r.Read (), "#31");
 479                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 480                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 481
 482                         Assert.IsTrue (r.Read (), "#41");
 483                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 484                         Assert.AreEqual ("MyMember", r.Value, "#43-2");
 485
 486                         Assert.IsTrue (r.Read (), "#51");
 487                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 488
 489                         Assert.IsTrue (r.Read (), "#61");
 490                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 491
 492                         Assert.IsFalse (r.Read (), "#71");
 493                         Assert.IsTrue (r.IsEof, "#72");
 494                 }
 495
 496                 [Test]
 497                 [Category ("NotWorking")]
 498                 public void Read_Array ()
 499                 {
 500                         var obj = new int [] {5, -3, 0};
 501                         var r = new XamlObjectReader (obj);
 502                         Read_ArrayOrArrayExtension (r, obj);
 503                 }
 504
 505                 [Test]
 506                 [Category ("NotWorking")]
 507                 public void Read_ArrayExtension ()
 508                 {
 509                         var obj = new ArrayExtension (new int [] {5, -3, 0});
 510                         var r = new XamlObjectReader (obj);
 511                         Read_ArrayOrArrayExtension (r, obj);
 512                 }
 513
 514                 void Read_ArrayOrArrayExtension (XamlObjectReader r, object instance)
 515                 {
 516                         Assert.IsTrue (r.Read (), "#11");
 517                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 518                         Assert.IsNotNull (r.Namespace, "#13");
 519                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 520                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 521
 522                         Assert.IsTrue (r.Read (), "#21");
 523                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 524                         var xt = new XamlType (typeof (ArrayExtension), r.SchemaContext);
 525                         Assert.AreEqual (xt, r.Type, "#23");
 526                         Assert.AreEqual (instance, r.Instance, "#26"); // different between Array and ArrayExtension
 527
 528                         Assert.IsTrue (r.Read (), "#31");
 529                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 530                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33");
 531
 532                         Assert.IsTrue (r.Read (), "#41");
 533                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 534                         Assert.AreEqual ("x:Int32", r.Value, "#43");
 535
 536                         Assert.IsTrue (r.Read (), "#51");
 537                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 538
 539                         Assert.IsTrue (r.Read (), "#61");
 540                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
 541                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
 542
 543                         Assert.IsTrue (r.Read (), "#71");
 544                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
 545                         Assert.IsNull (r.Type, "#71-3");
 546                         Assert.IsNull (r.Member, "#71-4");
 547                         Assert.IsNull (r.Value, "#71-5");
 548
 549                         Assert.IsTrue (r.Read (), "#72");
 550                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 551                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 552
 553                         string [] values = {"5", "-3", "0"};
 554                         for (int i = 0; i < 3; i++) {
 555                                 Assert.IsTrue (r.Read (), i + "#73");
 556                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 557                                 Assert.IsTrue (r.Read (), i + "#74");
 558                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 559                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 560                                 Assert.IsTrue (r.Read (), i + "#75");
 561                                 Assert.IsNotNull (r.Value, i + "#75-2");
 562                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 563                                 Assert.IsTrue (r.Read (), i + "#74");
 564                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 565                                 Assert.IsTrue (r.Read (), i + "#75");
 566                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 567                         }
 568
 569                         Assert.IsTrue (r.Read (), "#81");
 570                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 571
 572                         Assert.IsTrue (r.Read (), "#83");
 573                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
 574
 575                         Assert.IsTrue (r.Read (), "#85");
 576                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ArrayExtension.Items
 577
 578                         Assert.IsTrue (r.Read (), "#87");
 579                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ArrayExtension
 580
 581                         Assert.IsFalse (r.Read (), "#89");
 582                 }
 583
 584                 [Test] // It gives Type member, not PositionalParameters... and no Items member here.
 585                 [Category ("NotWorking")]
 586                 public void Read_ArrayExtension2 ()
 587                 {
 588                         var r = new XamlObjectReader (new ArrayExtension (typeof (int)));
 589                         Assert.IsTrue (r.Read (), "#11");
 590                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 591                         Assert.IsNotNull (r.Namespace, "#13");
 592                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 593                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 594                         Assert.IsNull (r.Instance, "#14");
 595
 596                         Assert.IsTrue (r.Read (), "#21");
 597                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 598                         var xt = new XamlType (typeof (ArrayExtension), r.SchemaContext);
 599                         Assert.AreEqual (xt, r.Type, "#23-2");
 600                         Assert.IsTrue (r.Instance is ArrayExtension, "#26");
 601
 602                         Assert.IsTrue (r.Read (), "#31");
 603                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 604                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33-2");
 605
 606                         Assert.IsTrue (r.Read (), "#41");
 607                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 608                         Assert.AreEqual ("x:Int32", r.Value, "#43-2");
 609
 610                         Assert.IsTrue (r.Read (), "#51");
 611                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 612
 613                         Assert.IsTrue (r.Read (), "#61");
 614                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 615
 616                         Assert.IsFalse (r.Read (), "#71");
 617                         Assert.IsTrue (r.IsEof, "#72");
 618                 }
 619
 620                 [Test]
 621                 public void Read_DateTime ()
 622                 {
 623                         var obj = new DateTime (2010, 4, 15);
 624                         var r = new XamlObjectReader (obj);
 625                         Read_CommonClrType (r, obj);
 626                         Assert.AreEqual ("2010-04-15", Read_Initialization (r, null), "#1");
 627                 }
 628
 629                 [Test]
 630                 public void Read_TimeSpan ()
 631                 {
 632                         Read_CommonXamlPrimitive (TimeSpan.FromMinutes (4));
 633                 }
 634
 635                 [Test]
 636                 public void Read_Uri ()
 637                 {
 638                         Read_CommonXamlPrimitive (new Uri ("urn:foo"));
 639                 }
 640
 641                 [Test]
 642                 [ExpectedException (typeof (XamlObjectReaderException))]
 643                 [Category ("NotWorking")]
 644                 public void Read_XData ()
 645                 {
 646                         var r = new XamlObjectReader (new XData () {Text = "xdata text"}); // XmlReader implementation is not visible.
 647                         while (!r.IsEof)
 648                                 r.Read ();
 649                 }
 650
 651                 [Test]
 652                 public void ReadStandardTypes ()
 653                 {
 654                         SimpleReadStandardType (new ArrayExtension ());
 655                         SimpleReadStandardType (new NullExtension ());
 656                         SimpleReadStandardType (new PropertyDefinition ());
 657                         SimpleReadStandardType (new Reference ());
 658                         SimpleReadStandardType (new StaticExtension ());
 659                         SimpleReadStandardType (new TypeExtension ());
 660                 }
 661
 662                 [Test]
 663                 public void Read_CustomMarkupExtension ()
 664                 {
 665                         var r = new XamlObjectReader (new MyExtension () { Foo = typeof (int), Bar = "v2"});
 666                         while (!r.IsEof) {
 667                                 r.Read ();
 668                                 if (r.Type != null && r.Type.UnderlyingType == typeof (MyExtension))
 669                                         break;
 670                         }
 671                         Assert.IsFalse (r.IsEof, "#1");
 672                         var xt = r.Type;
 673                         while (!r.IsEof) {
 674                                 r.Read ();
 675                                 if (r.Member != null && r.Member.Name == "Foo")
 676                                         break;
 677                         }
 678                         Assert.IsFalse (r.IsEof, "#2");
 679                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#3");
 680                         Assert.IsTrue (r.Read (), "#4");
 681                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#5");
 682                         Assert.AreEqual ("x:Int32", r.Value, "#6");
 683                 }
 684
 685                 [Test]
 686                 [Category ("NotWorking")]
 687                 public void Read_CustomMarkupExtension2 ()
 688                 {
 689                         var r = new XamlObjectReader (new MyExtension2 () { Foo = typeof (int), Bar = "v2"});
 690                         r.Read (); // ns
 691                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1");
 692                         r.Read ();
 693                         var xt = r.Type;
 694                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (MyExtension2)), xt, "#2");
 695                         Assert.IsTrue (r.Read (), "#3");
 696                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#4");
 697                         Assert.IsTrue (r.Read (), "#5");
 698                         Assert.AreEqual ("MonoTests.System.Xaml.MyExtension2", r.Value, "#6");
 699                         Assert.IsTrue (r.Read (), "#7"); // EndMember
 700                         Assert.IsTrue (r.Read (), "#8"); // EndObject
 701                         Assert.IsFalse (r.Read (), "#9");
 702                 }
 703
 704                 void SimpleReadStandardType (object instance)
 705                 {
 706                         var r = new XamlObjectReader (instance);
 707                         while (!r.IsEof)
 708                                 r.Read ();
 709                 }
 710
 711                 void Read_CommonXamlPrimitive (object obj)
 712                 {
 713                         var r = new XamlObjectReader (obj);
 714                         Read_CommonXamlType (r);
 715                         Read_Initialization (r, obj);
 716                 }
 717
 718                 // from StartMember of Initialization to EndMember
 719                 string Read_Initialization (XamlObjectReader r, object comparableValue)
 720                 {
 721                         Assert.IsTrue (r.Read (), "init#1");
 722                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "init#2");
 723                         Assert.IsNotNull (r.Member, "init#3");
 724                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "init#3-2");
 725                         Assert.IsTrue (r.Read (), "init#4");
 726                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "init#5");
 727                         Assert.AreEqual (typeof (string), r.Value.GetType (), "init#6");
 728                         string ret = (string) r.Value;
 729                         if (comparableValue != null)
 730                                 Assert.AreEqual (comparableValue.ToString (), r.Value, "init#6-2");
 731                         Assert.IsTrue (r.Read (), "init#7");
 732                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "init#8");
 733                         return ret;
 734                 }
 735
 736                 // from initial to StartObject
 737                 void Read_CommonXamlType (XamlObjectReader r)
 738                 {
 739                         Assert.IsTrue (r.Read (), "ct#1");
 740                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
 741                         Assert.IsNotNull (r.Namespace, "ct#3");
 742                         Assert.AreEqual ("x", r.Namespace.Prefix, "ct#3-2");
 743                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ct#3-3");
 744                         Assert.IsNull (r.Instance, "ct#4");
 745
 746                         Assert.IsTrue (r.Read (), "ct#5");
 747                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#6");
 748                 }
 749
 750                 // from initial to StartObject
 751                 void Read_CommonClrType (XamlObjectReader r, object obj)
 752                 {
 753                         Assert.IsTrue (r.Read (), "ct#1");
 754                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
 755                         Assert.IsNotNull (r.Namespace, "ct#3");
 756                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ct#3-2");
 757                         Assert.AreEqual ("clr-namespace:" + obj.GetType ().Namespace + ";assembly=" + obj.GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ct#3-3");
 758
 759 /*
 760                         Assert.IsTrue (r.Read (), "ct#4");
 761                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#5");
 762                         Assert.IsNotNull (r.Namespace, "ct#6");
 763                         Assert.AreEqual ("x", r.Namespace.Prefix, "ct#6-2");
 764                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ct#6-3");
 765 */
 766
 767                         Assert.IsTrue (r.Read (), "ct#7");
 768                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#8");
 769                 }
 770         }
 771
 772         class TestClass1
 773         {
 774         }
 775
 776         public class TestClass3
 777         {
 778                 public TestClass3 Nested { get; set; }
 779         }
 780
 781         [MarkupExtensionReturnType (typeof (Type))]
 782         public class MyExtension : MarkupExtension
 783         {
 784                 public MyExtension ()
 785                 {
 786                 }
 787
 788                 public MyExtension (Type arg1, string arg2)
 789                 {
 790                         Foo = arg1;
 791                         Bar = arg2;
 792                 }
 793
 794                 [ConstructorArgument ("arg1")]
 795                 public Type Foo { get; set; }
 796
 797                 [ConstructorArgument ("arg2")]
 798                 public string Bar { get; set; }
 799
 800                 public override object ProvideValue (IServiceProvider provider)
 801                 {
 802                         return "provided_value";
 803                 }
 804         }
 805
 806         [TypeConverter (typeof (StringConverter))] // This attribute is *the* difference between MyExtension and this type.
 807         public class MyExtension2 : MarkupExtension
 808         {
 809                 public MyExtension2 ()
 810                 {
 811                 }
 812
 813                 public MyExtension2 (Type arg1, string arg2)
 814                 {
 815                         Foo = arg1;
 816                         Bar = arg2;
 817                 }
 818
 819                 [ConstructorArgument ("arg1")]
 820                 public Type Foo { get; set; }
 821
 822                 [ConstructorArgument ("arg2")]
 823                 public string Bar { get; set; }
 824
 825                 public override object ProvideValue (IServiceProvider provider)
 826                 {
 827                         return "provided_value";
 828                 }
 829         }
 830 }