mcs/class/System.Xaml/Test/System.Xaml/XamlObjectWriterTest.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 namespace MonoTests.System.Xaml
  39 {
  40         [TestFixture]
  41         public class XamlObjectWriterTest
  42         {
  43                 PropertyInfo str_len = typeof (string).GetProperty ("Length");
  44                 XamlSchemaContext sctx = new XamlSchemaContext (null, null);
  45                 XamlType xt, xt2, xt3, xt4;
  46                 XamlMember xm, xm2, xm3;
  47
  48                 public XamlObjectWriterTest ()
  49                 {
  50                         xt = new XamlType (typeof (string), sctx);
  51                         xt2 = new XamlType (typeof (List<int>), sctx);
  52                         xt3 = new XamlType (typeof (TestClass1), sctx);
  53                         xt4 = new XamlType (typeof (Foo), sctx);
  54                         xm = new XamlMember (str_len, sctx);
  55                         xm2 = new XamlMember (typeof (TestClass1).GetProperty ("TestProp1"), sctx);
  56                         xm3 = new XamlMember (typeof (TestClass1).GetProperty ("TestProp2"), sctx);
  57                 }
  58
  59                 public class TestClass1
  60                 {
  61                         public TestClass1 ()
  62                         {
  63                                 TestProp3 = "foobar";
  64                         }
  65                         public string TestProp1 { get; set; }
  66                         // nested.
  67                         public TestClass1 TestProp2 { get; set; }
  68                         public string TestProp3 { get; set; }
  69                         public int TestProp4 { get; set; }
  70                 }
  71
  72                 public class Foo : List<int>
  73                 {
  74                         public Foo ()
  75                         {
  76                                 Bar = new List<string> ();
  77                         }
  78                         public List<string> Bar { get; private set; }
  79                         public List<string> Baz { get; set; }
  80                         public string Ext { get; set; }
  81                 }
  82
  83                 [Test]
  84                 [ExpectedException (typeof (ArgumentNullException))]
  85                 public void SchemaContextNull ()
  86                 {
  87                         new XamlObjectWriter (null);
  88                 }
  89
  90                 [Test]
  91                 public void SettingsNull ()
  92                 {
  93                         // allowed.
  94                         var w = new XamlObjectWriter (sctx, null);
  95                         Assert.AreEqual (sctx, w.SchemaContext, "#1");
  96                 }
  97
  98                 [Test]
  99                 [ExpectedException (typeof (XamlObjectWriterException))]
 100                 public void InitWriteEndMember ()
 101                 {
 102                         new XamlObjectWriter (sctx, null).WriteEndMember ();
 103                 }
 104
 105                 [Test]
 106                 [ExpectedException (typeof (XamlObjectWriterException))]
 107                 public void InitWriteEndObject ()
 108                 {
 109                         new XamlObjectWriter (sctx, null).WriteEndObject ();
 110                 }
 111
 112                 [Test]
 113                 [ExpectedException (typeof (XamlObjectWriterException))]
 114                 public void InitWriteGetObject ()
 115                 {
 116                         new XamlObjectWriter (sctx, null).WriteGetObject ();
 117                 }
 118
 119                 [Test]
 120                 [ExpectedException (typeof (XamlObjectWriterException))]
 121                 public void InitWriteValue ()
 122                 {
 123                         new XamlObjectWriter (sctx, null).WriteValue ("foo");
 124                 }
 125
 126                 [Test]
 127                 [ExpectedException (typeof (XamlObjectWriterException))]
 128                 public void InitWriteStartMember ()
 129                 {
 130                         new XamlObjectWriter (sctx, null).WriteStartMember (new XamlMember (str_len, sctx));
 131                 }
 132
 133                 [Test]
 134                 public void InitWriteNamespace ()
 135                 {
 136                         var xw = new XamlObjectWriter (sctx, null);
 137                         xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "x")); // ignored.
 138                         xw.Close ();
 139                         Assert.IsNull (xw.Result, "#1");
 140                 }
 141
 142                 [Test]
 143                 [ExpectedException (typeof (ArgumentNullException))]
 144                 public void WriteNamespaceNull ()
 145                 {
 146                         new XamlObjectWriter (sctx, null).WriteNamespace (null);
 147                 }
 148
 149                 [Test]
 150                 public void InitWriteStartObject ()
 151                 {
 152                         var xw = new XamlObjectWriter (sctx, null);
 153                         xw.WriteStartObject (new XamlType (typeof (int), sctx));
 154                         xw.Close ();
 155                         Assert.AreEqual (0, xw.Result, "#1");
 156                 }
 157
 158                 [Test]
 159                 [ExpectedException (typeof (XamlObjectWriterException))]
 160                 public void GetObjectAfterStartObject ()
 161                 {
 162                         var xw = new XamlObjectWriter (sctx, null);
 163                         xw.WriteStartObject (xt3);
 164                         xw.WriteGetObject ();
 165                 }
 166
 167                 [Test]
 168                 //[ExpectedException (typeof (XamlObjectWriterException))]
 169                 public void WriteStartObjectAfterTopLevel ()
 170                 {
 171                         var xw = new XamlObjectWriter (sctx, null);
 172                         xw.WriteStartObject (xt3);
 173                         xw.WriteEndObject ();
 174                         // writing another root is <del>not</del> allowed.
 175                         xw.WriteStartObject (xt3);
 176                 }
 177
 178                 [Test]
 179                 [ExpectedException (typeof (XamlObjectWriterException))]
 180                 public void WriteEndObjectExcess ()
 181                 {
 182                         var xw = new XamlObjectWriter (sctx, null);
 183                         xw.WriteStartObject (xt3);
 184                         xw.WriteEndObject ();
 185                         xw.WriteEndObject ();
 186                 }
 187
 188                 [Test]
 189                 [ExpectedException (typeof (XamlObjectWriterException))]
 190                 public void StartObjectWriteEndMember ()
 191                 {
 192                         var xw = new XamlObjectWriter (sctx, null);
 193                         xw.WriteStartObject (xt3);
 194                         xw.WriteEndMember ();
 195                 }
 196
 197                 [Test]
 198                 public void WriteObjectAndMember ()
 199                 {
 200                         var xw = new XamlObjectWriter (sctx, null);
 201                         xw.WriteStartObject (xt3);
 202                         xw.WriteStartMember (xm2);
 203                         xw.WriteValue ("foo");
 204                         xw.WriteEndMember ();
 205                         xw.Close ();
 206                 }
 207
 208                 [Test]
 209                 public void StartMemberWriteEndMember ()
 210                 {
 211                         var xw = new XamlObjectWriter (sctx, null);
 212                         xw.WriteStartObject (xt3);
 213                         xw.WriteStartMember (xm3);
 214                         xw.WriteEndMember (); // unlike XamlXmlWriter, it is not treated as an error...
 215                         xw.Close ();
 216                 }
 217
 218                 [Test]
 219                 [ExpectedException (typeof (XamlObjectWriterException))]
 220                 public void StartMemberWriteStartMember ()
 221                 {
 222                         var xw = new XamlObjectWriter (sctx, null);
 223                         xw.WriteStartObject (xt3);
 224                         xw.WriteStartMember (xm3);
 225                         xw.WriteStartMember (xm3);
 226                 }
 227
 228                 [Test]
 229                 public void WriteObjectInsideMember ()
 230                 {
 231                         var xw = new XamlObjectWriter (sctx, null);
 232                         xw.WriteStartObject (xt3);
 233                         xw.WriteStartMember (xm3);
 234                         xw.WriteStartObject (xt3);
 235                         xw.WriteEndObject ();
 236                         xw.WriteEndMember ();
 237                         xw.Close ();
 238                 }
 239
 240                 [Test]
 241                 [ExpectedException (typeof (XamlDuplicateMemberException))]
 242                 public void ValueAfterObject ()
 243                 {
 244                         var xw = new XamlObjectWriter (sctx, null);
 245                         xw.WriteStartObject (xt3);
 246                         xw.WriteStartMember (xm3);
 247                         xw.WriteStartObject (xt3);
 248                         xw.WriteEndObject ();
 249                         // passes here, but ...
 250                         xw.WriteValue ("foo");
 251                         // rejected here, unlike XamlXmlWriter.
 252                         xw.WriteEndMember ();
 253                 }
 254
 255                 [Test]
 256                 [ExpectedException (typeof (XamlDuplicateMemberException))]
 257                 public void ValueAfterObject2 ()
 258                 {
 259                         var xw = new XamlObjectWriter (sctx, null);
 260                         xw.WriteStartObject (xt3);
 261                         xw.WriteStartMember (xm3);
 262                         xw.WriteStartObject (xt3);
 263                         xw.WriteEndObject ();
 264                         // passes here, but should be rejected later.
 265                         xw.WriteValue ("foo");
 266
 267                         xw.WriteEndMember (); // Though this raises an error.
 268                 }
 269
 270                 [Test]
 271                 [ExpectedException (typeof (XamlDuplicateMemberException))]
 272                 public void DuplicateAssignment ()
 273                 {
 274                         var xw = new XamlObjectWriter (sctx, null);
 275                         xw.WriteStartObject (xt3);
 276                         xw.WriteStartMember (xm3);
 277                         xw.WriteStartObject (xt3);
 278                         xw.WriteEndObject ();
 279                         xw.WriteValue ("foo"); // causes duplicate assignment.
 280                         xw.WriteEndMember ();
 281                 }
 282
 283                 [Test]
 284                 [ExpectedException (typeof (XamlDuplicateMemberException))]
 285                 public void DuplicateAssignment2 ()
 286                 {
 287                         var xw = new XamlObjectWriter (sctx, null);
 288                         xw.WriteStartObject (xt3);
 289                         xw.WriteStartMember (xm3);
 290                         xw.WriteStartObject (xt3);
 291                         xw.WriteEndObject ();
 292                         xw.WriteEndMember ();
 293                         xw.WriteStartMember (xm3);
 294                 }
 295
 296                 [Test]
 297                 //[ExpectedException (typeof (ArgumentException))] // oh? XamlXmlWriter raises this.
 298                 [Category ("NotWorking")] // so, it's not worthy of passing.
 299                 public void WriteValueTypeMismatch ()
 300                 {
 301                         var xw = new XamlObjectWriter (sctx, null);
 302                         xw.WriteStartObject (xt);
 303                         xw.WriteStartMember (XamlLanguage.Initialization);
 304                         xw.WriteValue (new TestClass1 ());
 305                         xw.WriteEndMember ();
 306                         xw.Close ();
 307                         Assert.IsNotNull (xw.Result, "#1");
 308                         Assert.AreEqual (typeof (TestClass1), xw.Result.GetType (), "#2");
 309                 }
 310
 311                 [Test]
 312                 [ExpectedException (typeof (XamlObjectWriterException))] // it fails to convert type and set property value.
 313                 public void WriteValueTypeMismatch2 ()
 314                 {
 315                         var xw = new XamlObjectWriter (sctx, null);
 316                         xw.WriteStartObject (xt3);
 317                         xw.WriteStartMember (xm3);
 318                         xw.WriteValue ("foo");
 319                         xw.WriteEndMember ();
 320                 }
 321
 322                 [Test]
 323                 public void WriteValueTypeOK ()
 324                 {
 325                         var xw = new XamlObjectWriter (sctx, null);
 326                         xw.WriteStartObject (xt);
 327                         xw.WriteStartMember (XamlLanguage.Initialization);
 328                         xw.WriteValue ("foo");
 329                         xw.WriteEndMember ();
 330                         xw.Close ();
 331                         Assert.AreEqual ("foo", xw.Result, "#1");
 332                 }
 333
 334                 [Test]
 335                 // This behavior is different from XamlXmlWriter. Compare to XamlXmlWriterTest.WriteValueList().
 336                 [Category ("NotWorking")] // not worthy of passing
 337                 public void WriteValueList ()
 338                 {
 339                         var xw = new XamlObjectWriter (sctx, null);
 340                         xw.WriteStartObject (new XamlType (typeof (List<string>), sctx));
 341                         xw.WriteStartMember (XamlLanguage.Items);
 342                         xw.WriteValue ("foo");
 343                         xw.WriteValue ("bar");
 344                         xw.WriteEndMember ();
 345                         xw.Close ();
 346                         var l = xw.Result as List<string>;
 347                         Assert.IsNotNull (l, "#1");
 348                         Assert.AreEqual ("foo", l [0], "#2");
 349                         Assert.AreEqual ("bar", l [1], "#3");
 350                 }
 351
 352                 // I believe .NET XamlObjectWriter.Dispose() is hack and should
 353                 // be fixed to exactly determine which of End (member or object)
 354                 // to call that results in this ExpectedException.
 355                 // Surprisingly, PositionalParameters is allowed to be closed
 356                 // without EndMember. So it smells that .NET is hacky.
 357                 // We should disable this test and introduce better code (which
 358                 // is already in XamlWriterInternalBase).
 359                 [Test]
 360                 [ExpectedException (typeof (XamlObjectWriterException))]
 361                 [Ignore ("See the comment in XamlObjectWriterTest.cs")]
 362                 public void CloseWithoutEndMember ()
 363                 {
 364                         var xw = new XamlObjectWriter (sctx, null);
 365                         xw.WriteStartObject (xt);
 366                         xw.WriteStartMember (XamlLanguage.Initialization);
 367                         xw.WriteValue ("foo");
 368                         xw.Close ();
 369                 }
 370
 371                 [Test]
 372                 [ExpectedException (typeof (XamlObjectWriterException))]
 373                 public void WriteValueAfterValue ()
 374                 {
 375                         var xw = new XamlObjectWriter (sctx, null);
 376                         xw.WriteStartObject (xt);
 377                         xw.WriteValue ("foo");
 378                         xw.WriteValue ("bar");
 379                 }
 380
 381                 [Test]
 382                 [ExpectedException (typeof (XamlObjectWriterException))]
 383                 public void WriteValueAfterNullValue ()
 384                 {
 385                         var xw = new XamlObjectWriter (sctx, null);
 386                         xw.WriteStartObject (xt);
 387                         xw.WriteValue (null);
 388                         xw.WriteValue ("bar");
 389                 }
 390
 391                 [ExpectedException (typeof (XamlObjectWriterException))]
 392                 public void StartMemberWriteEndObject ()
 393                 {
 394                         var xw = new XamlObjectWriter (sctx, null);
 395                         xw.WriteStartObject (xt3);
 396                         xw.WriteStartMember (xm3);
 397                         xw.WriteEndObject ();
 398                 }
 399
 400                 [Test]
 401                 public void WriteNamespace ()
 402                 {
 403                         var xw = new XamlObjectWriter (sctx, null);
 404                         xw.WriteNamespace (new NamespaceDeclaration (XamlLanguage.Xaml2006Namespace, "x"));
 405                         xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "y"));
 406                         xw.WriteStartObject (xt3);
 407                         xw.WriteEndObject ();
 408                         xw.Close ();
 409                         var ret = xw.Result;
 410                         Assert.IsTrue (ret is TestClass1, "#1");
 411                 }
 412
 413                 [Test]
 414                 [ExpectedException (typeof (XamlObjectWriterException))]
 415                 public void StartObjectStartObject ()
 416                 {
 417                         var xw = new XamlObjectWriter (sctx, null);
 418                         xw.WriteStartObject (xt3);
 419                         xw.WriteStartObject (xt3);
 420                 }
 421
 422                 [Test]
 423                 [ExpectedException (typeof (XamlObjectWriterException))]
 424                 public void StartObjectValue ()
 425                 {
 426                         var xw = new XamlObjectWriter (sctx, null);
 427                         xw.WriteStartObject (xt3);
 428                         xw.WriteValue ("foo");
 429                 }
 430
 431                 [Test]
 432                 [ExpectedException (typeof (XamlDuplicateMemberException))] // duplicate member assignment
 433                 public void ObjectContainsObjectAndObject ()
 434                 {
 435                         var xw = new XamlObjectWriter (sctx, null);
 436                         xw.WriteStartObject (xt3);
 437                         xw.WriteStartMember (xm3);
 438                         xw.WriteStartObject (xt3);
 439                         xw.WriteEndObject ();
 440                         xw.WriteStartObject (xt3);
 441                         xw.WriteEndObject (); // the exception happens *here*
 442                         // FIXME: so, WriteEndMember() should not be required, but we fail here. Practically this difference should not matter.
 443                         xw.WriteEndMember (); // of xm3
 444                 }
 445
 446                 [Test]
 447                 [ExpectedException (typeof (XamlDuplicateMemberException))] // duplicate member assignment
 448                 public void ObjectContainsObjectAndValue ()
 449                 {
 450                         var xw = new XamlObjectWriter (sctx, null);
 451                         xw.WriteStartObject (xt3);
 452                         xw.WriteStartMember (xm3);
 453                         xw.WriteStartObject (xt3);
 454                         xw.WriteEndObject ();
 455                         xw.WriteValue ("foo"); // but this is allowed ...
 456
 457                         xw.WriteEndMember (); // Though this raises an error.
 458                 }
 459
 460                 [Test]
 461                 [ExpectedException (typeof (XamlDuplicateMemberException))] // duplicate member assignment
 462                 public void ObjectContainsObjectAndValue2 ()
 463                 {
 464                         var xw = new XamlObjectWriter (sctx, null);
 465                         xw.WriteStartObject (xt3);
 466                         xw.WriteStartMember (xm3);
 467                         xw.WriteStartObject (xt3);
 468                         xw.WriteEndObject ();
 469                         xw.WriteValue ("foo");
 470                         xw.WriteEndMember (); // ... until here.
 471                 }
 472
 473                 [Test]
 474                 [ExpectedException (typeof (XamlObjectWriterException))] // unlike XamlXmlWriter (IOE)
 475                 public void EndObjectAfterNamespace ()
 476                 {
 477                         var xw = new XamlObjectWriter (sctx, null);
 478                         xw.WriteStartObject (xt3);
 479                         xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "y"));
 480                         xw.WriteEndObject ();
 481                 }
 482
 483                 [Test]
 484                 [ExpectedException (typeof (XamlObjectWriterException))] // ... unlike XamlXmlWriter (throws IOE)
 485                 public void WriteValueAfterNamespace ()
 486                 {
 487                         var xw = new XamlObjectWriter (sctx, null);
 488                         xw.WriteStartObject (xt);
 489                         xw.WriteStartMember (XamlLanguage.Initialization);
 490                         xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "y"));
 491                         xw.WriteValue ("foo");
 492                 }
 493
 494                 [Test]
 495                 [ExpectedException (typeof (XamlObjectWriterException))] // ... unlike XamlXmlWriter (allowed)
 496                 public void ValueThenStartObject ()
 497                 {
 498                         var xw = new XamlObjectWriter (sctx, null);
 499                         xw.WriteStartObject (xt3);
 500                         xw.WriteStartMember (xm2);
 501                         xw.WriteValue ("foo");
 502                         xw.WriteStartObject (xt3);
 503                         xw.Close ();
 504                 }
 505
 506                 [Test]
 507                 [ExpectedException (typeof (XamlObjectWriterException))] // ... unlike XamlXmlWriter (allowed, as it allows StartObject after Value)
 508                 public void ValueThenNamespace ()
 509                 {
 510                         var xw = new XamlObjectWriter (sctx, null);
 511                         xw.WriteStartObject (xt3);
 512                         xw.WriteStartMember (xm2);
 513                         xw.WriteValue ("foo");
 514                         xw.WriteNamespace (new NamespaceDeclaration ("y", "urn:foo")); // this does not raise an error (since it might start another object)
 515                 }
 516
 517                 [Test]
 518                 [ExpectedException (typeof (XamlObjectWriterException))] // strange, this does *not* result in IOE...
 519                 public void ValueThenNamespaceThenEndMember ()
 520                 {
 521                         var xw = new XamlObjectWriter (sctx, null);
 522                         xw.WriteStartObject (xt3);
 523                         xw.WriteStartMember (xm2);
 524                         xw.WriteValue ("foo");
 525                         xw.WriteNamespace (new NamespaceDeclaration ("y", "urn:foo"));
 526                         xw.WriteEndMember ();
 527                 }
 528
 529                 [Test]
 530                 [ExpectedException (typeof (XamlObjectWriterException))] // This is also very different, requires exactly opposite namespace output manner to XamlXmlWriter (namespace first, object follows).
 531                 public void StartMemberAfterNamespace ()
 532                 {
 533                         var xw = new XamlObjectWriter (sctx, null);
 534                         xw.WriteStartObject (xt3);
 535                         xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "y"));
 536                 }
 537
 538                 [Test]
 539                 [Category ("NotWorking")] // not worthy of passing
 540                 public void StartMemberBeforeNamespace ()
 541                 {
 542                         var xw = new XamlObjectWriter (sctx, null);
 543                         xw.WriteStartObject (xt3);
 544                         xw.WriteStartMember (xm2); // note that it should be done *after* WriteNamespace in XamlXmlWriter. SO inconsistent.
 545                         xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "y"));
 546                         xw.WriteEndMember ();
 547                         xw.Close ();
 548                 }
 549
 550                 [Test]
 551                 [ExpectedException (typeof (XamlObjectWriterException))]
 552                 public void StartMemberBeforeNamespace2 ()
 553                 {
 554                         var xw = new XamlObjectWriter (sctx, null);
 555                         xw.WriteStartObject (xt3);
 556                         xw.WriteStartMember (xm2);
 557                         xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "y"));
 558                         // and here, NamespaceDeclaration is written as if it
 559                         // were another value object( unlike XamlXmlWriter)
 560                         // and rejects further value.
 561                         xw.WriteValue ("foo");
 562                 }
 563
 564                 [Test]
 565                 [ExpectedException (typeof (XamlObjectWriterException))]
 566                 public void EndMemberThenStartObject ()
 567                 {
 568                         var xw = new XamlObjectWriter (sctx, null);
 569                         xw.WriteStartObject (xt3);
 570                         xw.WriteStartMember (xm2);
 571                         xw.WriteValue ("foo");
 572                         xw.WriteEndMember ();
 573                         xw.WriteStartObject (xt3);
 574                 }
 575
 576                 // The semantics on WriteGetObject() is VERY different from XamlXmlWriter.
 577
 578                 [Test]
 579                 [ExpectedException (typeof (XamlObjectWriterException))]
 580                 public void GetObjectOnNullValue ()
 581                 {
 582                         var xw = new XamlObjectWriter (sctx, null);
 583                         xw.WriteStartObject (xt3);
 584                         xw.WriteStartMember (xm2);
 585                         xw.WriteGetObject ();
 586                 }
 587
 588                 [Test]
 589                 [ExpectedException (typeof (XamlObjectWriterException))]
 590                 public void GetObjectOnNullValue2 ()
 591                 {
 592                         var xw = new XamlObjectWriter (sctx, null);
 593                         xw.WriteStartObject (xt4);
 594                         xw.WriteStartMember (new XamlMember (typeof (Foo).GetProperty ("Baz"), sctx)); // unlike Bar, Baz is not initialized.
 595                         xw.WriteGetObject (); // fails, because it is null.
 596                 }
 597
 598                 [Test]
 599                 public void GetObjectOnIntValue ()
 600                 {
 601                         var xw = new XamlObjectWriter (sctx, null);
 602                         xw.WriteStartObject (xt3);
 603                         xw.WriteStartMember (xt3.GetMember ("TestProp4")); // int
 604                         xw.WriteGetObject (); // passes!!! WTF
 605                         xw.WriteEndObject ();
 606                 }
 607
 608                 [Test]
 609                 // String is not treated as a collection on XamlXmlWriter, while this XamlObjectWriter does.
 610                 public void GetObjectOnNonNullString ()
 611                 {
 612                         var xw = new XamlObjectWriter (sctx, null);
 613                         xw.WriteStartObject (xt3);
 614                         Assert.IsNull (xw.Result, "#1");
 615                         xw.WriteStartMember (xt3.GetMember ("TestProp3"));
 616                         xw.WriteGetObject ();
 617                         Assert.IsNull (xw.Result, "#2");
 618                 }
 619
 620                 [Test]
 621                 public void GetObjectOnCollection ()
 622                 {
 623                         var xw = new XamlObjectWriter (sctx, null);
 624                         xw.WriteStartObject (xt4);
 625                         xw.WriteStartMember (new XamlMember (typeof (Foo).GetProperty ("Bar"), sctx));
 626                         xw.WriteGetObject ();
 627                         xw.Close ();
 628                 }
 629
 630                 [Test]
 631                 [ExpectedException (typeof (XamlObjectWriterException))]
 632                 public void ValueAfterGetObject ()
 633                 {
 634                         var xw = new XamlObjectWriter (sctx, null);
 635                         xw.WriteStartObject (xt4);
 636                         xw.WriteStartMember (new XamlMember (typeof (Foo).GetProperty ("Bar"), sctx));
 637                         xw.WriteGetObject ();
 638                         xw.WriteValue ("foo");
 639                 }
 640
 641                 [Test]
 642                 [ExpectedException (typeof (XamlObjectWriterException))]
 643                 public void StartObjectAfterGetObject ()
 644                 {
 645                         var xw = new XamlObjectWriter (sctx, null);
 646                         xw.WriteStartObject (xt4);
 647                         xw.WriteStartMember (new XamlMember (typeof (Foo).GetProperty ("Bar"), sctx));
 648                         xw.WriteGetObject ();
 649                         xw.WriteStartObject (xt);
 650                 }
 651
 652                 [Test]
 653                 [ExpectedException (typeof (XamlObjectWriterException))]
 654                 public void EndMemberAfterGetObject ()
 655                 {
 656                         var xw = new XamlObjectWriter (sctx, null);
 657                         xw.WriteStartObject (xt4);
 658                         xw.WriteStartMember (new XamlMember (typeof (Foo).GetProperty ("Bar"), sctx));
 659                         xw.WriteGetObject ();
 660                         xw.WriteEndMember (); // ...!?
 661                 }
 662
 663                 [Test]
 664                 public void StartMemberAfterGetObject ()
 665                 {
 666                         var xw = new XamlObjectWriter (sctx, null);
 667                         xw.WriteStartObject (xt4);
 668                         var xmm = xt4.GetMember ("Bar");
 669                         xw.WriteStartMember (xmm); // <List.Bar>
 670                         xw.WriteGetObject (); // shifts current member to List<T>.
 671                         xw.WriteStartMember (xmm.Type.GetMember ("Capacity"));
 672                         xw.WriteValue (5);
 673                         xw.WriteEndMember ();
 674                         /*
 675                         xw.WriteEndObject (); // got object
 676                         xw.WriteEndMember (); // Bar
 677                         xw.WriteEndObject (); // started object
 678                         */
 679                         xw.Close ();
 680                 }
 681
 682                 [Test]
 683                 public void EndObjectAfterGetObject ()
 684                 {
 685                         var xw = new XamlObjectWriter (sctx, null);
 686                         xw.WriteStartObject (xt4);
 687                         xw.WriteStartMember (new XamlMember (typeof (Foo).GetProperty ("Bar"), sctx));
 688                         xw.WriteGetObject ();
 689                         xw.WriteEndObject ();
 690                 }
 691
 692                 [Test]
 693                 public void WriteAttachableProperty ()
 694                 {
 695                         Attached2 result = null;
 696
 697                         var rsettings = new XamlXmlReaderSettings ();
 698                         using (var reader = new XamlXmlReader (new StringReader (String.Format (@"<Attached2 AttachedWrapper3.Property=""Test"" xmlns=""clr-namespace:MonoTests.System.Xaml;assembly={0}""></Attached2>", typeof (AttachedWrapper3).Assembly.GetName ().Name)), rsettings)) {
 699                                 var wsettings = new XamlObjectWriterSettings ();
 700                                 using (var writer = new XamlObjectWriter (reader.SchemaContext, wsettings)) {
 701                                         XamlServices.Transform (reader, writer, false);
 702                                         result = (Attached2) writer.Result;
 703                                 }
 704                         }
 705
 706                         Assert.AreEqual ("Test", result.Property, "#1");
 707                 }
 708
 709                 [Test]
 710                 public void OnSetValueAndHandledFalse () // part of bug #3003
 711                 {
 712 #if NET_4_5
 713                         string ver = "net_4_5";
 714 #else
 715                         string ver = "net_4_0";
 716 #endif
 717
 718                         /*
 719                         var obj = new TestClass3 ();
 720                         obj.Nested = new TestClass3 ();
 721                         var sw = new StringWriter ();
 722                         var xxw = new XamlXmlWriter (XmlWriter.Create (sw), new XamlSchemaContext ());
 723                         XamlServices.Transform (new XamlObjectReader (obj), xxw);
 724                         Console.Error.WriteLine (sw);
 725                         */
 726                         var xml = "<TestClass3 xmlns='clr-namespace:MonoTests.System.Xaml;assembly=System.Xaml_test_net_4_0' xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'><TestClass3.Nested><TestClass3 Nested='{x:Null}' /></TestClass3.Nested></TestClass3>".Replace ("net_4_0", ver);
 727                         var settings = new XamlObjectWriterSettings ();
 728                         bool invoked = false;
 729                         settings.XamlSetValueHandler = (sender, e) => {
 730                                 invoked = true;
 731                                 Assert.IsNotNull (sender, "#1");
 732                                 Assert.AreEqual (typeof (TestClass3), sender.GetType (), "#2");
 733                                 Assert.AreEqual ("Nested", e.Member.Name, "#3");
 734                                 Assert.IsTrue (sender != e.Member.Invoker.GetValue (sender), "#4");
 735                                 Assert.IsFalse (e.Handled, "#5");
 736                                 // ... and leave Handled as false, to invoke the actual setter
 737                         };
 738                         var xow = new XamlObjectWriter (new XamlSchemaContext (), settings);
 739                         var xxr = new XamlXmlReader (XmlReader.Create (new StringReader (xml)));
 740                         XamlServices.Transform (xxr, xow);
 741                         Assert.IsTrue (invoked, "#6");
 742                         Assert.IsNotNull (xow.Result, "#7");
 743                         var ret = xow.Result as TestClass3;
 744                         Assert.IsNotNull (ret.Nested, "#8");
 745                 }
 746
 747                 [Test] // bug #3003 repro
 748                 public void EventsAndProcessingOrder ()
 749                 {
 750                         var asm = Assembly.GetExecutingAssembly ();
 751                         var context = new XamlSchemaContext (new Assembly [] { asm });
 752                         var output = XamarinBug3003.TestContext.Writer;
 753                         output.WriteLine ();
 754
 755                         var reader = new XamlXmlReader (XmlReader.Create (new StringReader (XamarinBug3003.TestContext.XmlInput)), context);
 756
 757                         var writerSettings = new XamlObjectWriterSettings ();
 758                         writerSettings.AfterBeginInitHandler = (sender, e) => {
 759                                 output.WriteLine ("XamlObjectWriterSettings.AfterBeginInit: {0}", e.Instance);
 760                         };
 761                         writerSettings.AfterEndInitHandler = (sender, e) => {
 762                                 output.WriteLine ("XamlObjectWriterSettings.AfterEndInit: {0}", e.Instance);
 763                         };
 764
 765                         writerSettings.BeforePropertiesHandler = (sender, e) => {
 766                                 output.WriteLine ("XamlObjectWriterSettings.BeforeProperties: {0}", e.Instance);
 767                         };
 768                         writerSettings.AfterPropertiesHandler = (sender, e) => {
 769                                 output.WriteLine ("XamlObjectWriterSettings.AfterProperties: {0}", e.Instance);
 770                         };
 771                         writerSettings.XamlSetValueHandler = (sender, e) => {
 772                                 output.WriteLine ("XamlObjectWriterSettings.XamlSetValue: {0}, Member: {1}", e.Value, e.Member.Name);
 773                         };
 774
 775                         var writer = new XamlObjectWriter (context, writerSettings);
 776                         XamlServices.Transform (reader, writer);
 777                         var obj = writer.Result as XamarinBug3003.Parent;
 778
 779                         output.WriteLine ("Loaded {0}", obj);
 780
 781                         Assert.AreEqual (XamarinBug3003.TestContext.ExpectedResult.Replace ("\r\n", "\n"), output.ToString ().Replace ("\r\n", "\n"), "#1");
 782
 783                         Assert.AreEqual (2, obj.Children.Count, "#2");
 784                 }
 785
 786                 // extra use case based tests.
 787
 788                 [Test]
 789                 public void WriteEx_Type_WriteString ()
 790                 {
 791                         var ow = new XamlObjectWriter (sctx);
 792                         ow.WriteNamespace (new NamespaceDeclaration (XamlLanguage.Xaml2006Namespace, "x"
 793                         ));
 794                         ow.WriteStartObject (XamlLanguage.Type);
 795                         ow.WriteStartMember (XamlLanguage.PositionalParameters);
 796                         ow.WriteValue ("x:Int32");
 797                         ow.Close ();
 798                         Assert.AreEqual (typeof (int), ow.Result, "#1");
 799                 }
 800
 801                 [Test]
 802                 public void WriteEx_Type_WriteType ()
 803                 {
 804                         var ow = new XamlObjectWriter (sctx);
 805                         ow.WriteNamespace (new NamespaceDeclaration (XamlLanguage.Xaml2006Namespace, "x"
 806                         ));
 807                         ow.WriteStartObject (XamlLanguage.Type);
 808                         ow.WriteStartMember (XamlLanguage.PositionalParameters);
 809                         ow.WriteValue (typeof (int));
 810                         ow.Close ();
 811                         Assert.AreEqual (typeof (int), ow.Result, "#1");
 812                 }
 813
 814                 [Test]
 815                 public void LookupCorrectEventBoundMethod ()
 816                 {
 817                         var o = (XamarinBug2927.MyRootClass) XamlServices.Load (GetReader ("LookupCorrectEvent.xml"));
 818                         o.Child.Descendant.Work ();
 819                         Assert.IsTrue (o.Invoked, "#1");
 820                         Assert.IsFalse (o.Child.Invoked, "#2");
 821                         Assert.IsFalse (o.Child.Descendant.Invoked, "#3");
 822                 }
 823
 824                 [Test]
 825                 [ExpectedException (typeof (XamlObjectWriterException))]
 826                 public void LookupCorrectEventBoundMethod2 ()
 827                 {
 828                         XamlServices.Load (GetReader ("LookupCorrectEvent2.xml"));
 829                 }
 830
 831                 [Test]
 832                 public void LookupCorrectEventBoundMethod3 ()
 833                 {
 834                         XamlServices.Load (GetReader ("LookupCorrectEvent3.xml"));
 835                 }
 836
 837                 // common use case based tests (to other readers/writers).
 838
 839                 XamlReader GetReader (string filename)
 840                 {
 841 #if NET_4_5
 842                         string ver = "net_4_5";
 843 #else
 844                         string ver = "net_4_0";
 845 #endif
 846                         string xml = File.ReadAllText (Path.Combine ("Test/XmlFiles", filename)).Replace ("net_4_0", ver);
 847                         return new XamlXmlReader (XmlReader.Create (new StringReader (xml)));
 848                 }
 849
 850                 [Test]
 851                 public void Write_String ()
 852                 {
 853                         using (var xr = GetReader ("String.xml")) {
 854                                 var des = XamlServices.Load (xr);
 855                                 Assert.AreEqual ("foo", des, "#1");
 856                         }
 857                 }
 858
 859                 [Test]
 860                 public void Write_Int32 ()
 861                 {
 862                         using (var xr = GetReader ("Int32.xml")) {
 863                                 var des = XamlServices.Load (xr);
 864                                 Assert.AreEqual (5, des, "#1");
 865                         }
 866                 }
 867
 868                 [Test]
 869                 public void Write_DateTime ()
 870                 {
 871                         using (var xr = GetReader ("DateTime.xml")) {
 872                                 var des = XamlServices.Load (xr);
 873                                 Assert.AreEqual (new DateTime (2010, 4, 14), des, "#1");
 874                         }
 875                 }
 876
 877                 [Test]
 878                 public void Write_TimeSpan ()
 879                 {
 880                         using (var xr = GetReader ("TimeSpan.xml")) {
 881                                 var des = XamlServices.Load (xr);
 882                                 Assert.AreEqual (TimeSpan.FromMinutes (7), des, "#1");
 883                         }
 884                 }
 885
 886                 [Test]
 887                 public void Write_Uri ()
 888                 {
 889                         using (var xr = GetReader ("Uri.xml")) {
 890                                 var des = XamlServices.Load (xr);
 891                                 Assert.AreEqual (new Uri ("urn:foo"), des, "#1");
 892                         }
 893                 }
 894
 895                 [Test]
 896                 public void Write_Null ()
 897                 {
 898                         using (var xr = GetReader ("NullExtension.xml")) {
 899                                 var des = XamlServices.Load (xr);
 900                                 Assert.IsNull (des, "#1");
 901                         }
 902                 }
 903
 904                 [Test]
 905                 public void Write_Type ()
 906                 {
 907                         using (var xr = GetReader ("Type.xml")) {
 908                                 var des = XamlServices.Load (xr);
 909                                 Assert.AreEqual (typeof (int), des, "#1");
 910                         }
 911                 }
 912
 913                 [Test]
 914                 public void Write_Type2 ()
 915                 {
 916                         var obj = typeof (MonoTests.System.Xaml.TestClass1);
 917                         using (var xr = GetReader ("Type2.xml")) {
 918                                 var des = XamlServices.Load (xr);
 919                                 Assert.AreEqual (obj, des, "#1");
 920                         }
 921                 }
 922
 923                 [Test]
 924                 public void Write_Guid ()
 925                 {
 926                         var obj = Guid.Parse ("9c3345ec-8922-4662-8e8d-a4e41f47cf09");
 927                         using (var xr = GetReader ("Guid.xml")) {
 928                                 var des = XamlServices.Load (xr);
 929                                 Assert.AreEqual (obj, des, "#1");
 930                         }
 931                 }
 932
 933                 [Test]
 934                 public void Write_GuidFactoryMethod ()
 935                 {
 936                         var obj = Guid.Parse ("9c3345ec-8922-4662-8e8d-a4e41f47cf09");
 937                         using (var xr = GetReader ("GuidFactoryMethod.xml")) {
 938                                 var des = XamlServices.Load (xr);
 939                                 Assert.AreEqual (obj, des, "#1");
 940                         }
 941                 }
 942
 943                 [Test]
 944                 [ExpectedException (typeof (XamlObjectWriterException))] // cannot resolve the StaticExtension value.
 945                 public void Write_StaticExtension ()
 946                 {
 947                         var obj = new StaticExtension ("FooBar");
 948                         using (var xr = GetReader ("StaticExtension.xml")) {
 949                                 var des = XamlServices.Load (xr);
 950                                 Assert.AreEqual (obj, des, "#1");
 951                         }
 952                 }
 953
 954                 [Test]
 955                 [Ignore ("Not sure why MemberType is NOT serialized. Needs investigation")]
 956                 public void Write_StaticExtension2 ()
 957                 {
 958                         var obj = new StaticExtension ("FooBar"); //incorrect
 959                         using (var xr = GetReader ("StaticExtension2.xml")) {
 960                                 var des = XamlServices.Load (xr);
 961                                 Assert.AreEqual (obj, des, "#1");
 962                         }
 963                 }
 964
 965                 [Test]
 966                 public void Write_Reference ()
 967                 {
 968                         using (var xr = GetReader ("Reference.xml")) {
 969                                 var des = XamlServices.Load (xr);
 970                                 // .NET does not return Reference.
 971                                 // Its ProvideValue() returns MS.Internal.Xaml.Context.NameFixupToken,
 972                                 // which is assumed (by name) to resolve to the referenced object.
 973                                 Assert.IsNotNull (des, "#1");
 974                                 //Assert.AreEqual (new Reference ("FooBar"), des, "#1");
 975                         }
 976                 }
 977
 978                 [Test]
 979                 public void Write_ArrayInt32 ()
 980                 {
 981                         var obj = new int [] {4, -5, 0, 255, int.MaxValue};
 982                         using (var xr = GetReader ("Array_Int32.xml")) {
 983                                 var des = XamlServices.Load (xr);
 984                                 Assert.AreEqual (obj, des, "#1");
 985                         }
 986                 }
 987
 988                 [Test]
 989                 public void Write_ListInt32 ()
 990                 {
 991                         var obj = new int [] {5, -3, int.MaxValue, 0}.ToList ();
 992                         using (var xr = GetReader ("List_Int32.xml")) {
 993                                 var des = (List<int>) XamlServices.Load (xr);
 994                                 Assert.AreEqual (obj.ToArray (), des.ToArray (), "#1");
 995                         }
 996                 }
 997
 998                 [Test]
 999                 public void Write_ListInt32_2 ()
1000                 {
1001                         var obj = new List<int> (new int [0]) { Capacity = 0 }; // set explicit capacity for trivial implementation difference
1002                         using (var xr = GetReader ("List_Int32_2.xml")) {
1003                                 var des = (List<int>) XamlServices.Load (xr);
1004                                 Assert.AreEqual (obj.ToArray (), des.ToArray (), "#1");
1005                         }
1006                 }
1007
1008                 [Test]
1009                 public void Write_ListType ()
1010                 {
1011                         var obj = new List<Type> (new Type [] {typeof (int), typeof (Dictionary<Type, XamlType>)}) { Capacity = 2 };
1012                         using (var xr = GetReader ("List_Type.xml")) {
1013                                 var des = XamlServices.Load (xr);
1014                                 Assert.AreEqual (obj, des, "#1");
1015                         }
1016                 }
1017
1018                 [Test]
1019                 public void Write_ListArray ()
1020                 {
1021                         var obj = new List<Array> (new Array [] { new int [] { 1,2,3}, new string [] { "foo", "bar", "baz" }}) { Capacity = 2 };
1022                         using (var xr = GetReader ("List_Array.xml")) {
1023                                 var des = (List<Array>) XamlServices.Load (xr);
1024                                 Assert.AreEqual (obj, des, "#1");
1025                         }
1026                 }
1027
1028                 [Test]
1029                 public void Write_DictionaryInt32String ()
1030                 {
1031                         var dic = new Dictionary<int,string> ();
1032                         dic.Add (0, "foo");
1033                         dic.Add (5, "bar");
1034                         dic.Add (-2, "baz");
1035                         using (var xr = GetReader ("Dictionary_Int32_String.xml")) {
1036                                 var des = XamlServices.Load (xr);
1037                                 Assert.AreEqual (dic, des, "#1");
1038                         }
1039                 }
1040
1041                 [Test]
1042                 public void Write_DictionaryStringType ()
1043                 {
1044                         var dic = new Dictionary<string,Type> ();
1045                         dic.Add ("t1", typeof (int));
1046                         dic.Add ("t2", typeof (int []));
1047                         dic.Add ("t3", typeof (int?));
1048                         dic.Add ("t4", typeof (List<int>));
1049                         dic.Add ("t5", typeof (Dictionary<int,DateTime>));
1050                         dic.Add ("t6", typeof (List<KeyValuePair<int,DateTime>>));
1051                         using (var xr = GetReader ("Dictionary_String_Type.xml")) {
1052                                 var des = XamlServices.Load (xr);
1053                                 Assert.AreEqual (dic, des, "#1");
1054                         }
1055                 }
1056
1057                 [Test]
1058                 [Ignore ("Needs to get successfully deserialized. Currently we can't")]
1059                 public void Write_PositionalParameters1Wrapper ()
1060                 {
1061                         // Unlike the above case, this has the wrapper object and hence PositionalParametersClass1 can be written as an attribute (markup extension)
1062                         var obj = new PositionalParametersWrapper ("foo", 5);
1063                         using (var xr = GetReader ("PositionalParametersWrapper.xml")) {
1064                                 var des = XamlServices.Load (xr);
1065                                 Assert.AreEqual (obj, des, "#1");
1066                         }
1067                 }
1068
1069                 [Test]
1070                 public void Write_ArgumentAttributed ()
1071                 {
1072                         //var obj = new ArgumentAttributed ("foo", "bar");
1073                         using (var xr = GetReader ("ArgumentAttributed.xml")) {
1074                                 var des = (ArgumentAttributed) XamlServices.Load (xr);
1075                                 Assert.AreEqual ("foo", des.Arg1, "#1");
1076                                 Assert.AreEqual ("bar", des.Arg2, "#2");
1077                         }
1078                 }
1079
1080                 [Test]
1081                 public void Write_ArrayExtension2 ()
1082                 {
1083                         //var obj = new ArrayExtension (typeof (int));
1084                         using (var xr = GetReader ("ArrayExtension2.xml")) {
1085                                 var des = XamlServices.Load (xr);
1086                                 // The resulting object is not ArrayExtension.
1087                                 Assert.AreEqual (new int [0], des, "#1");
1088                         }
1089                 }
1090
1091                 [Test]
1092                 public void Write_ArrayList ()
1093                 {
1094                         var obj = new ArrayList (new int [] {5, -3, 0});
1095                         using (var xr = GetReader ("ArrayList.xml")) {
1096                                 var des = XamlServices.Load (xr);
1097                                 Assert.AreEqual (obj, des, "#1");
1098                         }
1099                 }
1100
1101                 [Test]
1102                 [Ignore ("Needs to get successfully deserialized. Currently we can't")]
1103                 public void ComplexPositionalParameterWrapper ()
1104                 {
1105                         //var obj = new ComplexPositionalParameterWrapper () { Param = new ComplexPositionalParameterClass (new ComplexPositionalParameterValue () { Foo = "foo" })};
1106                         using (var xr = GetReader ("ComplexPositionalParameterWrapper.xml")) {
1107                                 var des = (ComplexPositionalParameterWrapper) XamlServices.Load (xr);
1108                                 Assert.IsNotNull (des.Param, "#1");
1109                                 Assert.AreEqual ("foo", des.Param.Value, "#2");
1110                         }
1111                 }
1112
1113                 [Test]
1114                 public void Write_ListWrapper ()
1115                 {
1116                         var obj = new ListWrapper (new List<int> (new int [] {5, -3, 0}) { Capacity = 3}); // set explicit capacity for trivial implementation difference
1117                         using (var xr = GetReader ("ListWrapper.xml")) {
1118                                 var des = (ListWrapper) XamlServices.Load (xr);
1119                                 Assert.IsNotNull (des, "#1");
1120                                 Assert.IsNotNull (des.Items, "#2");
1121                                 Assert.AreEqual (obj.Items.ToArray (), des.Items.ToArray (), "#3");
1122                         }
1123                 }
1124
1125                 [Test]
1126                 public void Write_ListWrapper2 ()
1127                 {
1128                         var obj = new ListWrapper2 (new List<int> (new int [] {5, -3, 0}) { Capacity = 3}); // set explicit capacity for trivial implementation difference
1129                         using (var xr = GetReader ("ListWrapper2.xml")) {
1130                                 var des = (ListWrapper2) XamlServices.Load (xr);
1131                                 Assert.IsNotNull (des, "#1");
1132                                 Assert.IsNotNull (des.Items, "#2");
1133                                 Assert.AreEqual (obj.Items.ToArray (), des.Items.ToArray (), "#3");
1134                         }
1135                 }
1136
1137                 [Test]
1138                 public void Write_MyArrayExtension ()
1139                 {
1140                         //var obj = new MyArrayExtension (new int [] {5, -3, 0});
1141                         using (var xr = GetReader ("MyArrayExtension.xml")) {
1142                                 var des = XamlServices.Load (xr);
1143                                 // ProvideValue() returns an array
1144                                 Assert.AreEqual (new int [] {5, -3, 0}, des, "#1");
1145                         }
1146                 }
1147
1148                 [Test]
1149                 public void Write_MyArrayExtensionA ()
1150                 {
1151                         //var obj = new MyArrayExtensionA (new int [] {5, -3, 0});
1152                         using (var xr = GetReader ("MyArrayExtensionA.xml")) {
1153                                 var des = XamlServices.Load (xr);
1154                                 // ProvideValue() returns an array
1155                                 Assert.AreEqual (new int [] {5, -3, 0}, des, "#1");
1156                         }
1157                 }
1158
1159                 [Test]
1160                 public void Write_MyExtension ()
1161                 {
1162                         //var obj = new MyExtension () { Foo = typeof (int), Bar = "v2", Baz = "v7"};
1163                         using (var xr = GetReader ("MyExtension.xml")) {
1164                                 var des = XamlServices.Load (xr);
1165                                 // ProvideValue() returns this.
1166                                 Assert.AreEqual ("provided_value", des, "#1");
1167                         }
1168                 }
1169
1170                 [Test]
1171                 [ExpectedException (typeof (InvalidCastException))] // unable to cast string to MarkupExtension
1172                 [Category ("NotWorking")]
1173                 public void Write_MyExtension2 ()
1174                 {
1175                         //var obj = new MyExtension2 () { Foo = typeof (int), Bar = "v2"};
1176                         using (var xr = GetReader ("MyExtension2.xml")) {
1177                                 XamlServices.Load (xr);
1178                         }
1179                 }
1180
1181                 [Test]
1182                 public void Write_MyExtension3 ()
1183                 {
1184                         //var obj = new MyExtension3 () { Foo = typeof (int), Bar = "v2"};
1185                         using (var xr = GetReader ("MyExtension3.xml")) {
1186                                 var des = XamlServices.Load (xr);
1187                                 // StringConverter is used and the resulting value comes from ToString().
1188                                 Assert.AreEqual ("MonoTests.System.Xaml.MyExtension3", des, "#1");
1189                         }
1190                 }
1191
1192                 [Test]
1193                 [ExpectedException (typeof (XamlObjectWriterException))] // wrong TypeConverter input (input string for DateTimeConverter invalid)
1194                 public void Write_MyExtension4 ()
1195                 {
1196                         var obj = new MyExtension4 () { Foo = typeof (int), Bar = "v2"};
1197                         using (var xr = GetReader ("MyExtension4.xml")) {
1198                                 var des = XamlServices.Load (xr);
1199                                 Assert.AreEqual (obj, des, "#1");
1200                         }
1201                 }
1202
1203                 [Test]
1204                 public void Write_MyExtension6 ()
1205                 {
1206                         //var obj = new MyExtension6 ("foo");
1207                         using (var xr = GetReader ("MyExtension6.xml")) {
1208                                 var des = XamlServices.Load (xr);
1209                                 // ProvideValue() returns this.
1210                                 Assert.AreEqual ("foo", des, "#1");
1211                         }
1212                 }
1213
1214                 [Test]
1215                 public void Write_PropertyDefinition ()
1216                 {
1217                         //var obj = new PropertyDefinition () { Modifier = "protected", Name = "foo", Type = XamlLanguage.String };
1218                         using (var xr = GetReader ("PropertyDefinition.xml")) {
1219                                 var des = (PropertyDefinition) XamlServices.Load (xr);
1220                                 Assert.AreEqual ("protected", des.Modifier, "#1");
1221                                 Assert.AreEqual ("foo", des.Name, "#2");
1222                                 Assert.AreEqual (XamlLanguage.String, des.Type, "#3");
1223                         }
1224                 }
1225
1226                 [Test]
1227                 [Ignore ("this still does not give successful deserialization result - should there be any way?")]
1228                 public void Write_StaticExtensionWrapper ()
1229                 {
1230                         //var obj = new StaticExtensionWrapper () { Param = new StaticExtension ("Foo") };
1231                         using (var xr = GetReader ("StaticExtensionWrapper.xml")) {
1232                                 var des = (StaticExtensionWrapper) XamlServices.Load (xr);
1233                                 Assert.IsNotNull (des.Param, "#1");
1234                                 Assert.AreEqual ("Foo", des.Param.Member, "#2");
1235                         }
1236                 }
1237
1238                 [Test]
1239                 [Ignore ("this still does not give successful deserialization result - should there be any way?")]
1240                 public void Write_TypeExtensionWrapper ()
1241                 {
1242                         //var obj = new TypeExtensionWrapper () { Param = new TypeExtension ("Foo") };
1243                         using (var xr = GetReader ("TypeExtensionWrapper.xml")) {
1244                                 var des = (TypeExtensionWrapper) XamlServices.Load (xr);
1245                                 Assert.IsNotNull (des.Param, "#1");
1246                                 // TypeName was not serialized into xml, hence deserialized as empty.
1247                                 Assert.AreEqual (String.Empty, des.Param.TypeName, "#2");
1248                         }
1249                 }
1250
1251                 [Test]
1252                 public void Write_NamedItems ()
1253                 {
1254                         // foo
1255                         // - bar
1256                         // -- foo
1257                         // - baz
1258                         var obj = new NamedItem ("foo");
1259                         var obj2 = new NamedItem ("bar");
1260                         obj.References.Add (obj2);
1261                         obj.References.Add (new NamedItem ("baz"));
1262                         obj2.References.Add (obj);
1263
1264                         using (var xr = GetReader ("NamedItems.xml")) {
1265                                 var des = (NamedItem) XamlServices.Load (xr);
1266                                 Assert.IsNotNull (des, "#1");
1267                                 Assert.AreEqual (2, des.References.Count, "#2");
1268                                 Assert.AreEqual (typeof (NamedItem), des.References [0].GetType (), "#3");
1269                                 Assert.AreEqual (typeof (NamedItem), des.References [1].GetType (), "#4");
1270                                 Assert.AreEqual (des, des.References [0].References [0], "#5");
1271                         }
1272                 }
1273
1274                 [Test]
1275                 public void Write_NamedItems2 ()
1276                 {
1277                         // i1
1278                         // - i2
1279                         // -- i3
1280                         // - i4
1281                         // -- i3
1282                         var obj = new NamedItem2 ("i1");
1283                         var obj2 = new NamedItem2 ("i2");
1284                         var obj3 = new NamedItem2 ("i3");
1285                         var obj4 = new NamedItem2 ("i4");
1286                         obj.References.Add (obj2);
1287                         obj.References.Add (obj4);
1288                         obj2.References.Add (obj3);
1289                         obj4.References.Add (obj3);
1290
1291                         using (var xr = GetReader ("NamedItems2.xml")) {
1292                                 var des = (NamedItem2) XamlServices.Load (xr);
1293                                 Assert.IsNotNull (des, "#1");
1294                                 Assert.AreEqual (2, des.References.Count, "#2");
1295                                 Assert.AreEqual (typeof (NamedItem2), des.References [0].GetType (), "#3");
1296                                 Assert.AreEqual (typeof (NamedItem2), des.References [1].GetType (), "#4");
1297                                 Assert.AreEqual (1, des.References [0].References.Count, "#5");
1298                                 Assert.AreEqual (1, des.References [1].References.Count, "#6");
1299                                 Assert.AreEqual (des.References [0].References [0], des.References [1].References [0], "#7");
1300                         }
1301                 }
1302
1303                 [Test]
1304                 public void Write_XmlSerializableWrapper ()
1305                 {
1306                         var assns = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name;
1307                         using (var xr = GetReader ("XmlSerializableWrapper.xml")) {
1308                                 var des = (XmlSerializableWrapper) XamlServices.Load (xr);
1309                                 Assert.IsNotNull (des, "#1");
1310                                 Assert.IsNotNull (des.Value, "#2");
1311                                 Assert.AreEqual ("<root xmlns=\"" + assns + "\" />", des.Value.GetRaw (), "#3");
1312                         }
1313                 }
1314
1315                 [Test]
1316                 public void Write_XmlSerializable ()
1317                 {
1318                         using (var xr = GetReader ("XmlSerializable.xml")) {
1319                                 var des = (XmlSerializable) XamlServices.Load (xr);
1320                                 Assert.IsNotNull (des, "#1");
1321                         }
1322                 }
1323
1324                 [Test]
1325                 public void Write_ListXmlSerializable ()
1326                 {
1327                         using (var xr = GetReader ("List_XmlSerializable.xml")) {
1328                                 var des = (List<XmlSerializable>) XamlServices.Load (xr);
1329                                 Assert.AreEqual (1, des.Count, "#1");
1330                         }
1331                 }
1332
1333                 [Test]
1334                 public void Write_AttachedProperty ()
1335                 {
1336                         using (var xr = GetReader ("AttachedProperty.xml")) {
1337                                 AttachedWrapper des = null;
1338                                 try {
1339                                         des = (AttachedWrapper) XamlServices.Load (xr);
1340                                         Assert.IsNotNull (des.Value, "#1");
1341                                         Assert.AreEqual ("x", Attachable.GetFoo (des), "#2");
1342                                         Assert.AreEqual ("y", Attachable.GetFoo (des.Value), "#3");
1343                                 } finally {
1344                                         if (des != null) {
1345                                                 Attachable.SetFoo (des, null);
1346                                                 Attachable.SetFoo (des.Value, null);
1347                                         }
1348                                 }
1349                         }
1350                 }
1351
1352                 [Test]
1353                 public void Write_EventStore ()
1354                 {
1355                         using (var xr = GetReader ("EventStore.xml")) {
1356                                 var res = (EventStore) XamlServices.Load (xr);
1357                                 Assert.AreEqual ("foo", res.Examine (), "#1");
1358                                 Assert.IsTrue (res.Method1Invoked, "#2");
1359                         }
1360                 }
1361
1362                 [Test]
1363                 [ExpectedException (typeof (XamlDuplicateMemberException))] // for two occurence of Event1 ...
1364                 public void Write_EventStore2 ()
1365                 {
1366                         using (var xr = GetReader ("EventStore2.xml")) {
1367                                 XamlServices.Load (xr);
1368                         }
1369                 }
1370
1371                 [Test]
1372                 [ExpectedException (typeof (XamlObjectWriterException))] // attaching nonexistent method
1373                 public void Write_EventStore3 ()
1374                 {
1375                         using (var xr = GetReader ("EventStore3.xml")) {
1376                                 XamlServices.Load (xr);
1377                         }
1378                 }
1379
1380                 [Test]
1381                 [Category ("NotWorking")] // type resolution failure.
1382                 public void Write_EventStore4 ()
1383                 {
1384                         using (var xr = GetReader ("EventStore4.xml")) {
1385                                 var res = (EventStore2<EventArgs>) XamlServices.Load (xr);
1386                                 Assert.AreEqual ("foo", res.Examine (), "#1");
1387                                 Assert.IsTrue (res.Method1Invoked, "#2");
1388                         }
1389                 }
1390
1391                 [Test]
1392                 public void Write_AbstractWrapper ()
1393                 {
1394                         using (var xr = GetReader ("AbstractContainer.xml")) {
1395                                 var res = (AbstractContainer) XamlServices.Load (xr);
1396                                 Assert.IsNull (res.Value1, "#1");
1397                                 Assert.IsNotNull (res.Value2, "#2");
1398                                 Assert.AreEqual ("x", res.Value2.Foo, "#3");
1399                         }
1400                 }
1401
1402                 [Test]
1403                 public void Write_ReadOnlyPropertyContainer ()
1404                 {
1405                         using (var xr = GetReader ("ReadOnlyPropertyContainer.xml")) {
1406                                 var res = (ReadOnlyPropertyContainer) XamlServices.Load (xr);
1407                                 Assert.AreEqual ("x", res.Foo, "#1");
1408                                 Assert.AreEqual ("x", res.Bar, "#2");
1409                         }
1410                 }
1411
1412                 [Test]
1413                 public void Write_TypeConverterOnListMember ()
1414                 {
1415                         using (var xr = GetReader ("TypeConverterOnListMember.xml")) {
1416                                 var res = (SecondTest.TypeOtherAssembly) XamlServices.Load (xr);
1417                                 Assert.AreEqual (3, res.Values.Count, "#1");
1418                                 Assert.AreEqual (3, res.Values [2], "#2");
1419                         }
1420                 }
1421
1422                 [Test]
1423                 public void Write_EnumContainer ()
1424                 {
1425                         using (var xr = GetReader ("EnumContainer.xml")) {
1426                                 var res = (EnumContainer) XamlServices.Load (xr);
1427                                 Assert.AreEqual (EnumValueType.Two, res.EnumProperty, "#1");
1428                         }
1429                 }
1430
1431                 [Test]
1432                 public void Write_CollectionContentProperty ()
1433                 {
1434                         using (var xr = GetReader ("CollectionContentProperty.xml")) {
1435                                 var res = (CollectionContentProperty) XamlServices.Load (xr);
1436                                 Assert.AreEqual (4, res.ListOfItems.Count, "#1");
1437                         }
1438                 }
1439
1440                 [Test]
1441                 public void Write_CollectionContentProperty2 ()
1442                 {
1443                         using (var xr = GetReader ("CollectionContentProperty2.xml")) {
1444                                 var res = (CollectionContentProperty) XamlServices.Load (xr);
1445                                 Assert.AreEqual (4, res.ListOfItems.Count, "#1");
1446                         }
1447                 }
1448
1449                 [Test]
1450                 public void Write_AmbientPropertyContainer ()
1451                 {
1452                         using (var xr = GetReader ("AmbientPropertyContainer.xml")) {
1453                                 var res = (SecondTest.ResourcesDict) XamlServices.Load (xr);
1454                                 Assert.AreEqual (2, res.Count, "#1");
1455                                 Assert.IsTrue (res.ContainsKey ("TestDictItem"), "#2");
1456                                 Assert.IsTrue (res.ContainsKey ("okay"), "#3");
1457                                 var i1 = res ["TestDictItem"] as SecondTest.TestObject;
1458                                 Assert.IsNull (i1.TestProperty, "#4");
1459                                 var i2 = res ["okay"] as SecondTest.TestObject;
1460                                 Assert.AreEqual (i1, i2.TestProperty, "#5");
1461                         }
1462                 }
1463
1464                 [Test] // bug #682102
1465                 public void Write_AmbientPropertyContainer2 ()
1466                 {
1467                         using (var xr = GetReader ("AmbientPropertyContainer2.xml")) {
1468                                 var res = (SecondTest.ResourcesDict) XamlServices.Load (xr);
1469                                 Assert.AreEqual (2, res.Count, "#1");
1470                                 Assert.IsTrue (res.ContainsKey ("TestDictItem"), "#2");
1471                                 Assert.IsTrue (res.ContainsKey ("okay"), "#3");
1472                                 var i1 = res ["TestDictItem"] as SecondTest.TestObject;
1473                                 Assert.IsNull (i1.TestProperty, "#4");
1474                                 var i2 = res ["okay"] as SecondTest.TestObject;
1475                                 Assert.AreEqual (i1, i2.TestProperty, "#5");
1476                         }
1477                 }
1478
1479                 [Test]
1480                 public void Write_NullableContainer ()
1481                 {
1482                         using (var xr = GetReader ("NullableContainer.xml")) {
1483                                 var res = (NullableContainer) XamlServices.Load (xr);
1484                                 Assert.AreEqual (5, res.TestProp, "#1");
1485                         }
1486                 }
1487
1488                 [Test]
1489                 public void Write_DirectListContainer ()
1490                 {
1491                         using (var xr = GetReader ("DirectListContainer.xml")) {
1492                                 var res = (DirectListContainer) XamlServices.Load (xr);
1493                                 Assert.AreEqual (3, res.Items.Count, "#1");
1494                                 Assert.AreEqual ("Hello3", res.Items [2].Value, "#2");
1495                         }
1496                 }
1497
1498                 [Test]
1499                 public void Write_DirectDictionaryContainer ()
1500                 {
1501                         using (var xr = GetReader ("DirectDictionaryContainer.xml")) {
1502                                 var res = (DirectDictionaryContainer) XamlServices.Load (xr);
1503                                 Assert.AreEqual (3, res.Items.Count, "#1");
1504                                 Assert.AreEqual (40, res.Items [EnumValueType.Three], "#2");
1505                         }
1506                 }
1507
1508                 [Test]
1509                 public void Write_DirectDictionaryContainer2 ()
1510                 {
1511                         using (var xr = GetReader ("DirectDictionaryContainer2.xml")) {
1512                                 var res = (SecondTest.ResourcesDict2) XamlServices.Load (xr);
1513                                 Assert.AreEqual (2, res.Count, "#1");
1514                                 Assert.AreEqual ("1", ((SecondTest.TestObject2) res ["1"]).TestProperty, "#2");
1515                                 Assert.AreEqual ("two", ((SecondTest.TestObject2) res ["two"]).TestProperty, "#3");
1516                         }
1517                 }
1518         }
1519 }