mcs/class/System.Xaml/Test/System.Xaml/XamlObjectReaderTest.cs

   1 //
   2 // Copyright (C) 2010 Novell Inc. http://novell.com
   3 //
   4 // Permission is hereby granted, free of charge, to any person obtaining
   5 // a copy of this software and associated documentation files (the
   6 // "Software"), to deal in the Software without restriction, including
   7 // without limitation the rights to use, copy, modify, merge, publish,
   8 // distribute, sublicense, and/or sell copies of the Software, and to
   9 // permit persons to whom the Software is furnished to do so, subject to
  10 // the following conditions:
  11 //
  12 // The above copyright notice and this permission notice shall be
  13 // included in all copies or substantial portions of the Software.
  14 //
  15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  19 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  20 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  21 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22 //
  23 using System;
  24 using System.Collections;
  25 using System.Collections.Generic;
  26 using System.ComponentModel;
  27 using System.IO;
  28 using System.Linq;
  29 using System.Reflection;
  30 using System.Windows.Markup;
  31 using System.Xaml;
  32 using System.Xaml.Schema;
  33 using System.Xml;
  34 using NUnit.Framework;
  35
  36 using CategoryAttribute = NUnit.Framework.CategoryAttribute;
  37
  38 namespace MonoTests.System.Xaml
  39 {
  40         [TestFixture]
  41         public partial class XamlObjectReaderTest : XamlReaderTestBase
  42         {
  43                 [Test]
  44                 public void ConstructorNullObject ()
  45                 {
  46                         // allowed.
  47                         new XamlObjectReader (null);
  48                 }
  49
  50                 [Test]
  51                 [ExpectedException (typeof (ArgumentNullException))]
  52                 public void ConstructorNullSchemaContext ()
  53                 {
  54                         new XamlObjectReader ("foo", (XamlSchemaContext) null);
  55                 }
  56
  57                 [Test]
  58                 public void ConstructorNullSettings ()
  59                 {
  60                         new XamlObjectReader ("foo", (XamlObjectReaderSettings) null);
  61                 }
  62
  63                 [Test]
  64                 [ExpectedException (typeof (ArgumentNullException))]
  65                 public void ConstructorNullSchemaContext2 ()
  66                 {
  67                         new XamlObjectReader ("foo", null, new XamlObjectReaderSettings ());
  68                 }
  69
  70                 [Test]
  71                 public void ConstructorNullSettings2 ()
  72                 {
  73                         new XamlObjectReader ("foo", new XamlSchemaContext (null, null), null);
  74                 }
  75
  76                 [Test]
  77                 [ExpectedException (typeof (XamlObjectReaderException))]
  78                 public void ReadNonConstructible ()
  79                 {
  80                         // XamlType has no default constructor.
  81                         new XamlObjectReader (XamlLanguage.String);
  82                 }
  83
  84                 [Test]
  85                 [ExpectedException (typeof (XamlObjectReaderException))]
  86                 public void NonPublicType ()
  87                 {
  88                         new XamlObjectReader (new TestClass1 ());
  89                 }
  90
  91                 [Test]
  92                 [ExpectedException (typeof (XamlObjectReaderException))]
  93                 public void NestedType ()
  94                 {
  95                         new XamlObjectReader (new TestClass2 ());
  96                 }
  97
  98                 public class TestClass2
  99                 {
 100                 }
 101
 102                 [Test]
 103                 public void ConstructibleType ()
 104                 {
 105                         new XamlObjectReader (new TestClass3 ());
 106                 }
 107
 108                 // Based on Common tests
 109
 110                 [Test]
 111                 public void Read_String ()
 112                 {
 113                         var r = new XamlObjectReader ("foo");
 114                         Read_String (r);
 115                 }
 116
 117                 [Test]
 118                 public void WriteNullMemberAsObject ()
 119                 {
 120                         var r = new XamlObjectReader (new TestClass4 ());
 121                         WriteNullMemberAsObject (r, delegate {
 122                                 Assert.IsNull (r.Instance, "#x"); }
 123                                 );
 124                 }
 125
 126                 [Test]
 127                 public void StaticMember ()
 128                 {
 129                         var r = new XamlObjectReader (new TestClass5 ());
 130                         StaticMember (r);
 131                 }
 132
 133                 [Test]
 134                 public void Skip ()
 135                 {
 136                         var r = new XamlObjectReader ("Foo");
 137                         Skip (r);
 138                 }
 139
 140                 [Test]
 141                 public void Skip2 ()
 142                 {
 143                         var r = new XamlObjectReader ("Foo");
 144                         Skip2 (r);
 145                 }
 146
 147                 [Test]
 148                 public void Read_XmlDocument ()
 149                 {
 150                         var doc = new XmlDocument ();
 151                         doc.LoadXml ("<root xmlns='urn:foo'><elem attr='val' /></root>");
 152                         var r = new XamlObjectReader (doc);
 153                         Read_XmlDocument (r);
 154                 }
 155
 156                 [Test]
 157                 public void Read_NonPrimitive ()
 158                 {
 159                         var r = new XamlObjectReader (new TestClass3 ());
 160                         Read_NonPrimitive (r);
 161                 }
 162
 163                 [Test]
 164                 public void Read_Type ()
 165                 {
 166                         var r = new XamlObjectReader (typeof (int));
 167                         Read_TypeOrTypeExtension (r);
 168                 }
 169
 170                 [Test]
 171                 public void Read_TypeExtension ()
 172                 {
 173                         var tx = new TypeExtension (typeof (int));
 174                         var r = new XamlObjectReader (tx);
 175                         Read_TypeOrTypeExtension (r);
 176                 }
 177
 178                 void Read_TypeOrTypeExtension (XamlObjectReader r)
 179                 {
 180                         Read_TypeOrTypeExtension (r, delegate {
 181                                 Assert.IsTrue (r.Instance is TypeExtension, "#26");
 182                                 }, XamlLanguage.PositionalParameters);
 183                 }
 184
 185                 [Test]
 186                 public void Read_Type2 ()
 187                 {
 188                         var r = new XamlObjectReader (typeof (TestClass1));
 189                         Read_TypeOrTypeExtension2 (r);
 190                 }
 191
 192                 [Test]
 193                 public void Read_TypeExtension2 ()
 194                 {
 195                         var r = new XamlObjectReader (new TypeExtension (typeof (TestClass1)));
 196                         Read_TypeOrTypeExtension2 (r);
 197                 }
 198
 199                 void Read_TypeOrTypeExtension2 (XamlObjectReader r)
 200                 {
 201                         Read_TypeOrTypeExtension2 (r, delegate {
 202                                 Assert.IsTrue (r.Instance is TypeExtension, "#26");
 203                         }, XamlLanguage.PositionalParameters);
 204                 }
 205
 206                 [Test]
 207                 public void Read_Reference ()
 208                 {
 209                         var r = new XamlObjectReader (new Reference ("FooBar"));
 210                         Read_Reference (r);
 211                 }
 212
 213                 [Test]
 214                 public void Read_Null ()
 215                 {
 216                         var r = new XamlObjectReader (null);
 217                         Read_NullOrNullExtension (r, (object) null);
 218                 }
 219
 220                 [Test]
 221                 public void Read_NullExtension ()
 222                 {
 223                         var o = new NullExtension ();
 224                         var r = new XamlObjectReader (o);
 225                         Read_NullOrNullExtension (r, o);
 226                 }
 227
 228                 void Read_NullOrNullExtension (XamlObjectReader r, object instance)
 229                 {
 230                         Read_NullOrNullExtension (r, delegate {
 231                                 Assert.AreEqual (instance, r.Instance, "#26"); // null and NullExtension are different here.
 232                         });
 233                 }
 234
 235                 [Test]
 236                 public void Read_StaticExtension ()
 237                 {
 238                         var r = new XamlObjectReader (new StaticExtension ("FooBar"));
 239                         Read_StaticExtension (r, XamlLanguage.PositionalParameters);
 240                 }
 241
 242                 [Test]
 243                 public void Read_ListInt32 ()
 244                 {
 245                         var obj = new List<int> (new int [] {5, -3, int.MaxValue, 0});
 246                         Read_ListInt32 (obj);
 247                 }
 248
 249                 [Test]
 250                 public void Read_ListInt32_2 ()
 251                 {
 252                         var obj = new List<int> (new int [0]);
 253                         Read_ListInt32 (obj);
 254                 }
 255
 256                 void Read_ListInt32 (List<int> obj)
 257                 {
 258                         var r = new XamlObjectReader (obj);
 259                         Read_ListInt32 (r, delegate {
 260                                 Assert.AreEqual (obj, r.Instance, "#26");
 261                                 }, obj);
 262                 }
 263
 264                 [Test]
 265                 public void Read_ListType ()
 266                 {
 267                         var obj = new List<Type> (new Type [] {typeof (int), typeof (Dictionary<Type, XamlType>)}) { Capacity = 2 };
 268                         var r = new XamlObjectReader (obj);
 269                         Read_ListType (r, true);
 270                 }
 271
 272                 [Test]
 273                 public void Read_ListArray ()
 274                 {
 275                         var obj = new List<Array> (new Array [] { new int [] { 1,2,3}, new string [] { "foo", "bar", "baz" }}) { Capacity = 2 };
 276                         var r = new XamlObjectReader (obj);
 277                         Read_ListArray (r);
 278                 }
 279
 280                 [Test]
 281                 public void Read_ArrayList ()
 282                 {
 283                         var obj = new ArrayList (new int [] {5, -3, 0});
 284                         var r = new XamlObjectReader (obj);
 285                         Read_ArrayList (r);
 286                 }
 287
 288                 [Test]
 289                 public void Read_Array ()
 290                 {
 291                         var obj = new int [] {5, -3, 0};
 292                         var r = new XamlObjectReader (obj);
 293                         Read_ArrayOrArrayExtension (r, obj);
 294                 }
 295
 296                 [Test]
 297                 public void Read_ArrayExtension ()
 298                 {
 299                         var obj = new ArrayExtension (new int [] {5, -3, 0});
 300                         var r = new XamlObjectReader (obj);
 301                         Read_ArrayOrArrayExtension (r, obj);
 302                 }
 303
 304                 [Test]
 305                 public void Read_MyArrayExtension ()
 306                 {
 307                         var obj = new MyArrayExtension (new int [] {5, -3, 0});
 308                         var r = new XamlObjectReader (obj);
 309                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, obj, typeof (MyArrayExtension));
 310                 }
 311
 312                 void Read_ArrayOrArrayExtension (XamlObjectReader r, object instance)
 313                 {
 314                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, instance, typeof (ArrayExtension));
 315                 }
 316
 317                 void Read_ArrayOrArrayExtensionOrMyArrayExtension (XamlObjectReader r, object instance, Type extType)
 318                 {
 319                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, delegate {
 320                                 Assert.AreEqual (instance, r.Instance, "#26"); // different between Array and ArrayExtension. Also, different from Type and TypeExtension (Type returns TypeExtension, while Array remains to return Array)
 321                                 }, extType);
 322                 }
 323
 324                 [Test]
 325                 public void Read_ArrayExtension2 ()
 326                 {
 327                         var r = new XamlObjectReader (new ArrayExtension (typeof (int)));
 328                         Read_ArrayExtension2 (r);
 329                 }
 330
 331                 [Test]
 332                 public void Read_DateTime ()
 333                 {
 334                         var obj = new DateTime (2010, 4, 15);
 335                         var r = new XamlObjectReader (obj);
 336                         Read_CommonClrType (r, obj);
 337                         Assert.AreEqual ("2010-04-15", Read_Initialization (r, null), "#1");
 338                 }
 339
 340                 [Test]
 341                 public void Read_TimeSpan ()
 342                 {
 343                         Read_CommonXamlPrimitive (TimeSpan.FromMinutes (4));
 344                 }
 345
 346                 [Test]
 347                 public void Read_Uri ()
 348                 {
 349                         Read_CommonXamlPrimitive (new Uri ("urn:foo"));
 350                 }
 351
 352                 [Test]
 353                 public void Read_Guid ()
 354                 {
 355                         var obj = Guid.NewGuid ();
 356                         var r = new XamlObjectReader (obj);
 357                         Assert.IsNotNull (r.SchemaContext.GetXamlType (typeof (Guid)).TypeConverter, "premise#1");
 358                         Read_CommonClrType (r, obj);
 359                         Assert.AreEqual (obj.ToString (), Read_Initialization (r, null), "#1");
 360                 }
 361
 362                 [Test]
 363                 [ExpectedException (typeof (XamlObjectReaderException))]
 364                 [Category ("NotWorking")]
 365                 public void Read_XData ()
 366                 {
 367                         var r = new XamlObjectReader (new XData () {Text = "xdata text"}); // XmlReader implementation is not visible.
 368                         while (!r.IsEof)
 369                                 r.Read ();
 370                 }
 371
 372                 [Test]
 373                 [ExpectedException (typeof (XamlObjectReaderException))]
 374                 [Category ("NotWorking")]
 375                 public void Read_XDataWrapper ()
 376                 {
 377                         var obj = new XDataWrapper () { Markup = new XData () {Text = "<my_xdata/>" } };
 378                         var r = new XamlObjectReader (obj);
 379                         while (!r.IsEof)
 380                                 r.Read ();
 381                 }
 382
 383                 [Test]
 384                 public void ReadStandardTypes ()
 385                 {
 386                         SimpleReadStandardType (new ArrayExtension ());
 387                         SimpleReadStandardType (new NullExtension ());
 388                         SimpleReadStandardType (new PropertyDefinition ());
 389                         SimpleReadStandardType (new Reference ());
 390                         SimpleReadStandardType (new StaticExtension ());
 391                         SimpleReadStandardType (new TypeExtension ());
 392                 }
 393
 394                 void SimpleReadStandardType (object instance)
 395                 {
 396                         var r = new XamlObjectReader (instance);
 397                         while (!r.IsEof)
 398                                 r.Read ();
 399                 }
 400
 401                 [Test]
 402                 public void Read_CustomMarkupExtension ()
 403                 {
 404                         var r = new XamlObjectReader (new MyExtension () { Foo = typeof (int), Bar = "v2", Baz = "v7"});
 405                         Read_CustomMarkupExtension (r);
 406                 }
 407
 408                 [Test]
 409                 public void Read_CustomMarkupExtension2 ()
 410                 {
 411                         var r = new XamlObjectReader (new MyExtension2 () { Foo = typeof (int), Bar = "v2"});
 412                         Read_CustomMarkupExtension2 (r);
 413                 }
 414
 415                 [Test]
 416                 public void Read_CustomMarkupExtension3 ()
 417                 {
 418                         var r = new XamlObjectReader (new MyExtension3 () { Foo = typeof (int), Bar = "v2"});
 419                         Read_CustomMarkupExtension3 (r);
 420                 }
 421
 422                 [Test]
 423                 public void Read_CustomMarkupExtension4 ()
 424                 {
 425                         var r = new XamlObjectReader (new MyExtension4 () { Foo = typeof (int), Bar = "v2"});
 426                         Read_CustomMarkupExtension4 (r);
 427                 }
 428
 429                 [Test]
 430                 public void Read_CustomMarkupExtension5 ()
 431                 {
 432                         // This cannot be written to XamlXmlWriter though...
 433
 434                         var r = new XamlObjectReader (new MyExtension5 ("foo", "bar"));
 435                         Read_CustomMarkupExtension5 (r);
 436                 }
 437
 438                 [Test]
 439                 public void Read_CustomMarkupExtension6 ()
 440                 {
 441                         var r = new XamlObjectReader (new MyExtension6 ("foo"));
 442                         Read_CustomMarkupExtension6 (r);
 443                 }
 444
 445                 [Test]
 446                 public void Read_ArgumentAttributed ()
 447                 {
 448                         var obj = new ArgumentAttributed ("foo", "bar");
 449                         var r = new XamlObjectReader (obj);
 450                         Read_ArgumentAttributed (r, obj);
 451                 }
 452
 453                 [Test]
 454                 public void Read_Dictionary ()
 455                 {
 456                         var obj = new Dictionary<string,object> ();
 457                         obj ["Foo"] = 5.0;
 458                         obj ["Bar"] = -6.5;
 459                         var r = new XamlObjectReader (obj);
 460                         Read_Dictionary (r);
 461                 }
 462
 463                 [Test]
 464                 public void Read_Dictionary2 ()
 465                 {
 466                         var obj = new Dictionary<string,Type> ();
 467                         obj ["Foo"] = typeof (int);
 468                         obj ["Bar"] = typeof (Dictionary<Type,XamlType>);
 469                         var r = new XamlObjectReader (obj);
 470                         Read_Dictionary2 (r, XamlLanguage.PositionalParameters);
 471                 }
 472
 473                 [Test]
 474                 public void PositionalParameters1 ()
 475                 {
 476                         // Note: this can be read, but cannot be written to XML.
 477                         var obj = new PositionalParametersClass1 ("foo", 5);
 478                         var r = new XamlObjectReader (obj);
 479                         PositionalParameters1 (r);
 480                 }
 481
 482                 [Test]
 483                 public void PositionalParameters2 ()
 484                 {
 485                         var obj = new PositionalParametersWrapper ("foo", 5);
 486                         var r = new XamlObjectReader (obj);
 487                         PositionalParameters2 (r);
 488                 }
 489
 490                 [Test]
 491                 public void ComplexPositionalParameters ()
 492                 {
 493                         var obj = new ComplexPositionalParameterWrapper () { Param = new ComplexPositionalParameterClass (new ComplexPositionalParameterValue () { Foo = "foo" })};
 494                         var r = new XamlObjectReader (obj);
 495                         ComplexPositionalParameters (r);
 496                 }
 497
 498                 [Test]
 499                 public void Read_ListWrapper ()
 500                 {
 501                         var obj = new ListWrapper (new List<int> (new int [] {5, -3, 0}));
 502                         var r = new XamlObjectReader (obj);
 503                         Read_ListWrapper (r);
 504                 }
 505
 506                 [Test]
 507                 public void Read_ListWrapper2 () // read-write list member.
 508                 {
 509                         var obj = new ListWrapper2 (new List<int> (new int [] {5, -3, 0}));
 510                         var r = new XamlObjectReader (obj);
 511                         Read_ListWrapper2 (r);
 512                 }
 513
 514                 [Test]
 515                 public void Read_ContentIncluded ()
 516                 {
 517                         var obj = new ContentIncludedClass () { Content = "foo" };
 518                         var r = new XamlObjectReader (obj);
 519                         Read_ContentIncluded (r);
 520                 }
 521
 522                 [Test]
 523                 public void Read_PropertyDefinition ()
 524                 {
 525                         var obj = new PropertyDefinition () { Modifier = "protected", Name = "foo", Type = XamlLanguage.String };
 526                         var r = new XamlObjectReader (obj);
 527                         Read_PropertyDefinition (r);
 528                 }
 529
 530                 [Test]
 531                 public void Read_StaticExtensionWrapper ()
 532                 {
 533                         var obj = new StaticExtensionWrapper () { Param = new StaticExtension ("StaticExtensionWrapper.Foo") };
 534                         var r = new XamlObjectReader (obj);
 535                         Read_StaticExtensionWrapper (r);
 536                 }
 537
 538                 [Test]
 539                 public void Read_TypeExtensionWrapper ()
 540                 {
 541                         var obj = new TypeExtensionWrapper () { Param = new TypeExtension ("Foo") };
 542                         var r = new XamlObjectReader (obj);
 543                         Read_TypeExtensionWrapper (r);
 544                 }
 545
 546                 [Test]
 547                 public void Read_EventContainer ()
 548                 {
 549                         var obj = new EventContainer ();
 550                         obj.Run += delegate { Console.Error.WriteLine ("done"); };
 551                         var xr = new XamlObjectReader (obj);
 552                         Read_EventContainer (xr);
 553                 }
 554
 555                 [Test]
 556                 public void Read_NamedItems ()
 557                 {
 558                         // foo
 559                         // - bar
 560                         // -- foo
 561                         // - baz
 562                         var obj = new NamedItem ("foo");
 563                         var obj2 = new NamedItem ("bar");
 564                         obj.References.Add (obj2);
 565                         obj.References.Add (new NamedItem ("baz"));
 566                         obj2.References.Add (obj);
 567
 568                         var xr = new XamlObjectReader (obj);
 569                         Read_NamedItems (xr, true);
 570                 }
 571
 572                 [Test]
 573                 public void Read_NamedItems2 ()
 574                 {
 575                         // i1
 576                         // - i2
 577                         // -- i3
 578                         // - i4
 579                         // -- i3
 580                         var obj = new NamedItem2 ("i1");
 581                         var obj2 = new NamedItem2 ("i2");
 582                         var obj3 = new NamedItem2 ("i3");
 583                         var obj4 = new NamedItem2 ("i4");
 584                         obj.References.Add (obj2);
 585                         obj.References.Add (obj4);
 586                         obj2.References.Add (obj3);
 587                         obj4.References.Add (obj3);
 588
 589                         var xr = new XamlObjectReader (obj);
 590                         Read_NamedItems2 (xr, true);
 591                 }
 592
 593                 [Test]
 594                 [Category ("NotWorking")]
 595                 public void Read_XmlSerializableWrapper ()
 596                 {
 597                         var obj = new XmlSerializableWrapper (new XmlSerializable ("<root/>"));
 598                         var xr = new XamlObjectReader (obj);
 599                         Read_XmlSerializableWrapper (xr, true);
 600                 }
 601
 602                 [Test] // If it is root, it is not serialized as IXmlSerializable.
 603                 public void Read_XmlSerializable ()
 604                 {
 605                         var obj = new XmlSerializable ("<root/>");
 606                         var xr = new XamlObjectReader (obj);
 607                         Read_XmlSerializable (xr);
 608                 }
 609
 610                 [Test] // List contents are (sort of) treated as top-level too, so it is not serialized as IXmlSerializable(!)
 611                 public void Read_ListXmlSerializable ()
 612                 {
 613                         var obj = new List<XmlSerializable> ();
 614                         obj.Add (new XmlSerializable ("<root/>"));
 615                         var xr = new XamlObjectReader (obj);
 616                         Read_ListXmlSerializable (xr);
 617                 }
 618         }
 619 }