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                 [Category ("NotWorking")] // namespace node differences
 338                 public void Read_Type2 ()
 339                 {
 340                         var r = new XamlObjectReader (typeof (TestClass1));
 341                         Read_TypeOrTypeExtension2 (r);
 342                 }
 343
 344                 [Test]
 345                 [Category ("NotWorking")] // namespace node differences
 346                 public void Read_TypeExtension2 ()
 347                 {
 348                         var r = new XamlObjectReader (new TypeExtension (typeof (TestClass1)));
 349                         Read_TypeOrTypeExtension2 (r);
 350                 }
 351
 352                 void Read_TypeOrTypeExtension2 (XamlObjectReader r)
 353                 {
 354                         Assert.IsTrue (r.Read (), "#11");
 355                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 356
 357                         var nsmap = new Dictionary<string,string> ();
 358                         nsmap ["x"] = XamlLanguage.Xaml2006Namespace;
 359                         nsmap [String.Empty] = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name;
 360
 361                         Assert.IsTrue (nsmap.ContainsKey (r.Namespace.Prefix), "#13-2");
 362                         Assert.AreEqual (nsmap [r.Namespace.Prefix], r.Namespace.Namespace, "#13-3:" + r.Namespace.Prefix);
 363                         nsmap.Remove (r.Namespace.Prefix);
 364
 365                         Assert.IsTrue (r.Read (), "#16");
 366                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#17");
 367                         Assert.IsNotNull (r.Namespace, "#18");
 368                         Assert.IsTrue (nsmap.ContainsKey (r.Namespace.Prefix), "#18-2");
 369                         Assert.AreEqual (nsmap [r.Namespace.Prefix], r.Namespace.Namespace, "#18-3:" + r.Namespace.Prefix);
 370                         nsmap.Remove (r.Namespace.Prefix);
 371
 372                         Assert.IsTrue (r.Read (), "#21");
 373                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 374                         Assert.AreEqual (new XamlType (typeof (TypeExtension), r.SchemaContext), r.Type, "#23-2");
 375                         Assert.IsTrue (r.Instance is TypeExtension, "#26");
 376
 377                         Assert.IsTrue (r.Read (), "#31");
 378                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 379                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 380
 381                         Assert.IsTrue (r.Read (), "#41");
 382                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 383                         Assert.AreEqual ("TestClass1", r.Value, "#43-2");
 384
 385                         Assert.IsTrue (r.Read (), "#51");
 386                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 387
 388                         Assert.IsTrue (r.Read (), "#61");
 389                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 390
 391                         Assert.IsFalse (r.Read (), "#71");
 392                         Assert.IsTrue (r.IsEof, "#72");
 393                 }
 394
 395                 [Test]
 396                 public void Read_Reference ()
 397                 {
 398                         var r = new XamlObjectReader (new Reference ("TestName"));
 399                         Assert.IsTrue (r.Read (), "#11");
 400                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 401                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 402                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 403
 404                         Assert.IsTrue (r.Read (), "#21");
 405                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 406                         var xt = new XamlType (typeof (Reference), r.SchemaContext);
 407                         Assert.AreEqual (xt, r.Type, "#23-2");
 408                         Assert.IsTrue (r.Instance is Reference, "#26");
 409
 410                         Assert.IsTrue (r.Read (), "#31");
 411                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 412                         // unlike TypeExtension there is no PositionalParameters.
 413                         Assert.AreEqual (xt.GetMember ("Name"), r.Member, "#33-2");
 414
 415                         // It is a ContentProperty (besides [ConstructorArgument])
 416                         Assert.IsTrue (r.Read (), "#41");
 417                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 418                         Assert.AreEqual ("TestName", r.Value, "#43-2");
 419
 420                         Assert.IsTrue (r.Read (), "#51");
 421                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 422
 423                         Assert.IsTrue (r.Read (), "#61");
 424                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 425
 426                         Assert.IsFalse (r.Read (), "#71");
 427                         Assert.IsTrue (r.IsEof, "#72");
 428                 }
 429
 430
 431                 [Test]
 432                 public void Read_Null ()
 433                 {
 434                         var r = new XamlObjectReader (null);
 435                         Read_NullOrNullExtension (r, null);
 436                 }
 437
 438                 [Test]
 439                 public void Read_NullExtension ()
 440                 {
 441                         var o = new NullExtension ();
 442                         var r = new XamlObjectReader (o);
 443                         Read_NullOrNullExtension (r, o);
 444                 }
 445
 446                 void Read_NullOrNullExtension (XamlObjectReader r, object instance)
 447                 {
 448                         Assert.IsTrue (r.Read (), "#11");
 449                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 450                         Assert.IsNotNull (r.Namespace, "#13");
 451                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 452                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 453                         Assert.IsNull (r.Instance, "#14");
 454
 455                         Assert.IsTrue (r.Read (), "#21");
 456                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 457                         Assert.AreEqual (new XamlType (typeof (NullExtension), r.SchemaContext), r.Type, "#23-2");
 458                         Assert.AreEqual (instance, r.Instance, "#26"); // null and NullExtension are different here.
 459
 460                         Assert.IsTrue (r.Read (), "#61");
 461                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 462
 463                         Assert.IsFalse (r.Read (), "#71");
 464                         Assert.IsTrue (r.IsEof, "#72");
 465                 }
 466
 467                 [Test] // almost identical to TypeExtension (only type/instance difference)
 468                 [Category ("NotWorking")]
 469                 public void Read_StaticExtension ()
 470                 {
 471                         var r = new XamlObjectReader (new StaticExtension ("MyMember"));
 472                         Assert.IsTrue (r.Read (), "#11");
 473                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 474                         Assert.IsNotNull (r.Namespace, "#13");
 475                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 476                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 477                         Assert.IsNull (r.Instance, "#14");
 478
 479                         Assert.IsTrue (r.Read (), "#21");
 480                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 481                         Assert.AreEqual (new XamlType (typeof (StaticExtension), r.SchemaContext), r.Type, "#23-2");
 482                         Assert.IsTrue (r.Instance is StaticExtension, "#26");
 483
 484                         Assert.IsTrue (r.Read (), "#31");
 485                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 486                         Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, "#33-2");
 487
 488                         Assert.IsTrue (r.Read (), "#41");
 489                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 490                         Assert.AreEqual ("MyMember", r.Value, "#43-2");
 491
 492                         Assert.IsTrue (r.Read (), "#51");
 493                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 494
 495                         Assert.IsTrue (r.Read (), "#61");
 496                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62");
 497
 498                         Assert.IsFalse (r.Read (), "#71");
 499                         Assert.IsTrue (r.IsEof, "#72");
 500                 }
 501
 502                 [Test]
 503                 [Category ("NotWorking")]
 504                 public void Read_Array ()
 505                 {
 506                         var obj = new int [] {5, -3, 0};
 507                         var r = new XamlObjectReader (obj);
 508                         Read_ArrayOrArrayExtension (r, obj);
 509                 }
 510
 511                 [Test]
 512                 [Category ("NotWorking")]
 513                 public void Read_ArrayExtension ()
 514                 {
 515                         var obj = new ArrayExtension (new int [] {5, -3, 0});
 516                         var r = new XamlObjectReader (obj);
 517                         Read_ArrayOrArrayExtension (r, obj);
 518                 }
 519
 520                 void Read_ArrayOrArrayExtension (XamlObjectReader r, object instance)
 521                 {
 522                         Assert.IsTrue (r.Read (), "#11");
 523                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12");
 524                         Assert.IsNotNull (r.Namespace, "#13");
 525                         Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2");
 526                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3");
 527
 528                         Assert.IsTrue (r.Read (), "#21");
 529                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22");
 530                         var xt = new XamlType (typeof (ArrayExtension), r.SchemaContext);
 531                         Assert.AreEqual (xt, r.Type, "#23");
 532                         Assert.AreEqual (instance, r.Instance, "#26"); // different between Array and ArrayExtension
 533
 534                         Assert.IsTrue (r.Read (), "#31");
 535                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32");
 536                         Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33");
 537
 538                         Assert.IsTrue (r.Read (), "#41");
 539                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42");
 540                         Assert.AreEqual ("x:Int32", r.Value, "#43");
 541
 542                         Assert.IsTrue (r.Read (), "#51");
 543                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52");
 544
 545                         Assert.IsTrue (r.Read (), "#61");
 546                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62");
 547                         Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63");
 548
 549                         Assert.IsTrue (r.Read (), "#71");
 550                         Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2");
 551                         Assert.IsNull (r.Type, "#71-3");
 552                         Assert.IsNull (r.Member, "#71-4");
 553                         Assert.IsNull (r.Value, "#71-5");
 554
 555                         Assert.IsTrue (r.Read (), "#72");
 556                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2");
 557                         Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3");
 558
 559                         string [] values = {"5", "-3", "0"};
 560                         for (int i = 0; i < 3; i++) {
 561                                 Assert.IsTrue (r.Read (), i + "#73");
 562                                 Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2");
 563                                 Assert.IsTrue (r.Read (), i + "#74");
 564                                 Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2");
 565                                 Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3");
 566                                 Assert.IsTrue (r.Read (), i + "#75");
 567                                 Assert.IsNotNull (r.Value, i + "#75-2");
 568                                 Assert.AreEqual (values [i], r.Value, i + "#73-3");
 569                                 Assert.IsTrue (r.Read (), i + "#74");
 570                                 Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2");
 571                                 Assert.IsTrue (r.Read (), i + "#75");
 572                                 Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2");
 573                         }
 574
 575                         Assert.IsTrue (r.Read (), "#81");
 576                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items
 577
 578                         Assert.IsTrue (r.Read (), "#83");
 579                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject
 580
 581                         Assert.IsTrue (r.Read (), "#85");
 582                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ArrayExtension.Items
 583
 584                         Assert.IsTrue (r.Read (), "#87");
 585                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ArrayExtension
 586
 587                         Assert.IsFalse (r.Read (), "#89");
 588                 }
 589
 590                 [Test]
 591                 public void Read_DateTime ()
 592                 {
 593                         var obj = new DateTime (2010, 4, 15);
 594                         var r = new XamlObjectReader (obj);
 595                         Read_CommonClrType (r, obj);
 596                         Assert.AreEqual ("2010-04-15", Read_Initialization (r, null), "#1");
 597                 }
 598
 599                 [Test]
 600                 public void Read_TimeSpan ()
 601                 {
 602                         Read_CommonXamlPrimitive (TimeSpan.FromMinutes (4));
 603                 }
 604
 605                 [Test]
 606                 public void Read_Uri ()
 607                 {
 608                         Read_CommonXamlPrimitive (new Uri ("urn:foo"));
 609                 }
 610
 611                 [Test]
 612                 [ExpectedException (typeof (XamlObjectReaderException))]
 613                 [Category ("NotWorking")]
 614                 public void Read_XData ()
 615                 {
 616                         var r = new XamlObjectReader (new XData () {Text = "xdata text"}); // XmlReader implementation is not visible.
 617                         while (!r.IsEof)
 618                                 r.Read ();
 619                 }
 620
 621                 [Test]
 622                 public void ReadStandardTypes ()
 623                 {
 624                         SimpleReadStandardType (new ArrayExtension ());
 625                         SimpleReadStandardType (new NullExtension ());
 626                         SimpleReadStandardType (new PropertyDefinition ());
 627                         SimpleReadStandardType (new Reference ());
 628                         SimpleReadStandardType (new StaticExtension ());
 629                         SimpleReadStandardType (new TypeExtension ());
 630                 }
 631
 632                 [Test]
 633                 public void Read_CustomMarkupExtension ()
 634                 {
 635                         var r = new XamlObjectReader (new MyExtension () { Foo = typeof (int), Bar = "v2"});
 636                         while (!r.IsEof) {
 637                                 r.Read ();
 638                                 if (r.Type != null && r.Type.UnderlyingType == typeof (MyExtension))
 639                                         break;
 640                         }
 641                         Assert.IsFalse (r.IsEof, "#1");
 642                         var xt = r.Type;
 643                         while (!r.IsEof) {
 644                                 r.Read ();
 645                                 if (r.Member != null && r.Member.Name == "Foo")
 646                                         break;
 647                         }
 648                         Assert.IsFalse (r.IsEof, "#2");
 649                         Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#3");
 650                         Assert.IsTrue (r.Read (), "#4");
 651                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#5");
 652                         Assert.AreEqual ("x:Int32", r.Value, "#6");
 653                 }
 654
 655                 void SimpleReadStandardType (object instance)
 656                 {
 657                         var r = new XamlObjectReader (instance);
 658                         while (!r.IsEof)
 659                                 r.Read ();
 660                 }
 661
 662                 void Read_CommonXamlPrimitive (object obj)
 663                 {
 664                         var r = new XamlObjectReader (obj);
 665                         Read_CommonXamlType (r);
 666                         Read_Initialization (r, obj);
 667                 }
 668
 669                 // from StartMember of Initialization to EndMember
 670                 string Read_Initialization (XamlObjectReader r, object comparableValue)
 671                 {
 672                         Assert.IsTrue (r.Read (), "init#1");
 673                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "init#2");
 674                         Assert.IsNotNull (r.Member, "init#3");
 675                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "init#3-2");
 676                         Assert.IsTrue (r.Read (), "init#4");
 677                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "init#5");
 678                         Assert.AreEqual (typeof (string), r.Value.GetType (), "init#6");
 679                         string ret = (string) r.Value;
 680                         if (comparableValue != null)
 681                                 Assert.AreEqual (comparableValue.ToString (), r.Value, "init#6-2");
 682                         Assert.IsTrue (r.Read (), "init#7");
 683                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "init#8");
 684                         return ret;
 685                 }
 686
 687                 // from initial to StartObject
 688                 void Read_CommonXamlType (XamlObjectReader r)
 689                 {
 690                         Assert.IsTrue (r.Read (), "ct#1");
 691                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
 692                         Assert.IsNotNull (r.Namespace, "ct#3");
 693                         Assert.AreEqual ("x", r.Namespace.Prefix, "ct#3-2");
 694                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ct#3-3");
 695                         Assert.IsNull (r.Instance, "ct#4");
 696
 697                         Assert.IsTrue (r.Read (), "ct#5");
 698                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#6");
 699                 }
 700
 701                 // from initial to StartObject
 702                 void Read_CommonClrType (XamlObjectReader r, object obj)
 703                 {
 704                         Assert.IsTrue (r.Read (), "ct#1");
 705                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2");
 706                         Assert.IsNotNull (r.Namespace, "ct#3");
 707                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ct#3-2");
 708                         Assert.AreEqual ("clr-namespace:" + obj.GetType ().Namespace + ";assembly=" + obj.GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ct#3-3");
 709
 710 /*
 711                         Assert.IsTrue (r.Read (), "ct#4");
 712                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#5");
 713                         Assert.IsNotNull (r.Namespace, "ct#6");
 714                         Assert.AreEqual ("x", r.Namespace.Prefix, "ct#6-2");
 715                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ct#6-3");
 716 */
 717
 718                         Assert.IsTrue (r.Read (), "ct#7");
 719                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#8");
 720                 }
 721         }
 722
 723         class TestClass1
 724         {
 725         }
 726
 727         public class TestClass3
 728         {
 729                 public TestClass3 Nested { get; set; }
 730         }
 731
 732         [MarkupExtensionReturnType (typeof (Type))]
 733         public class MyExtension : MarkupExtension
 734         {
 735                 public MyExtension ()
 736                 {
 737                 }
 738
 739                 public MyExtension (Type arg1, string arg2)
 740                 {
 741                         Foo = arg1;
 742                         Bar = arg2;
 743                 }
 744
 745                 [ConstructorArgument ("arg1")]
 746                 public Type Foo { get; set; }
 747
 748                 [ConstructorArgument ("arg2")]
 749                 public string Bar { get; set; }
 750
 751                 public override object ProvideValue (IServiceProvider provider)
 752                 {
 753                         return "provided_value";
 754                 }
 755         }
 756 }