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                 public void ReadStandardTypes ()
 374                 {
 375                         SimpleReadStandardType (new ArrayExtension ());
 376                         SimpleReadStandardType (new NullExtension ());
 377                         SimpleReadStandardType (new PropertyDefinition ());
 378                         SimpleReadStandardType (new Reference ());
 379                         SimpleReadStandardType (new StaticExtension ());
 380                         SimpleReadStandardType (new TypeExtension ());
 381                 }
 382
 383                 void SimpleReadStandardType (object instance)
 384                 {
 385                         var r = new XamlObjectReader (instance);
 386                         while (!r.IsEof)
 387                                 r.Read ();
 388                 }
 389
 390                 [Test]
 391                 public void Read_CustomMarkupExtension ()
 392                 {
 393                         var r = new XamlObjectReader (new MyExtension () { Foo = typeof (int), Bar = "v2", Baz = "v7"});
 394                         Read_CustomMarkupExtension (r);
 395                 }
 396
 397                 [Test]
 398                 public void Read_CustomMarkupExtension2 ()
 399                 {
 400                         var r = new XamlObjectReader (new MyExtension2 () { Foo = typeof (int), Bar = "v2"});
 401                         Read_CustomMarkupExtension2 (r);
 402                 }
 403
 404                 [Test]
 405                 public void Read_CustomMarkupExtension3 ()
 406                 {
 407                         var r = new XamlObjectReader (new MyExtension3 () { Foo = typeof (int), Bar = "v2"});
 408                         Read_CustomMarkupExtension3 (r);
 409                 }
 410
 411                 [Test]
 412                 public void Read_CustomMarkupExtension4 ()
 413                 {
 414                         var r = new XamlObjectReader (new MyExtension4 () { Foo = typeof (int), Bar = "v2"});
 415                         Read_CustomMarkupExtension4 (r);
 416                 }
 417
 418                 [Test]
 419                 public void Read_CustomMarkupExtension5 ()
 420                 {
 421                         // This cannot be written to XamlXmlWriter though...
 422
 423                         var r = new XamlObjectReader (new MyExtension5 ("foo", "bar"));
 424                         Read_CustomMarkupExtension5 (r);
 425                 }
 426
 427                 [Test]
 428                 public void Read_CustomMarkupExtension6 ()
 429                 {
 430                         var r = new XamlObjectReader (new MyExtension6 ("foo"));
 431                         Read_CustomMarkupExtension6 (r);
 432                 }
 433
 434                 [Test]
 435                 public void Read_ArgumentAttributed ()
 436                 {
 437                         var obj = new ArgumentAttributed ("foo", "bar");
 438                         var r = new XamlObjectReader (obj);
 439                         Read_ArgumentAttributed (r, obj);
 440                 }
 441
 442                 [Test]
 443                 public void Read_Dictionary ()
 444                 {
 445                         var obj = new Dictionary<string,object> ();
 446                         obj ["Foo"] = 5.0;
 447                         obj ["Bar"] = -6.5;
 448                         var r = new XamlObjectReader (obj);
 449                         Read_Dictionary (r);
 450                 }
 451
 452                 [Test]
 453                 public void Read_Dictionary2 ()
 454                 {
 455                         var obj = new Dictionary<string,Type> ();
 456                         obj ["Foo"] = typeof (int);
 457                         obj ["Bar"] = typeof (Dictionary<Type,XamlType>);
 458                         var r = new XamlObjectReader (obj);
 459                         Read_Dictionary2 (r, XamlLanguage.PositionalParameters);
 460                 }
 461
 462                 [Test]
 463                 public void PositionalParameters1 ()
 464                 {
 465                         // Note: this can be read, but cannot be written to XML.
 466                         var obj = new PositionalParametersClass1 ("foo", 5);
 467                         var r = new XamlObjectReader (obj);
 468                         PositionalParameters1 (r);
 469                 }
 470
 471                 [Test]
 472                 public void PositionalParameters2 ()
 473                 {
 474                         var obj = new PositionalParametersWrapper ("foo", 5);
 475                         var r = new XamlObjectReader (obj);
 476                         PositionalParameters2 (r);
 477                 }
 478
 479                 [Test]
 480                 public void ComplexPositionalParameters ()
 481                 {
 482                         var obj = new ComplexPositionalParameterWrapper () { Param = new ComplexPositionalParameterClass (new ComplexPositionalParameterValue () { Foo = "foo" })};
 483                         var r = new XamlObjectReader (obj);
 484                         ComplexPositionalParameters (r);
 485                 }
 486
 487                 [Test]
 488                 public void Read_ListWrapper ()
 489                 {
 490                         var obj = new ListWrapper (new List<int> (new int [] {5, -3, 0}));
 491                         var r = new XamlObjectReader (obj);
 492                         Read_ListWrapper (r);
 493                 }
 494
 495                 [Test]
 496                 public void Read_ListWrapper2 () // read-write list member.
 497                 {
 498                         var obj = new ListWrapper2 (new List<int> (new int [] {5, -3, 0}));
 499                         var r = new XamlObjectReader (obj);
 500                         Read_ListWrapper2 (r);
 501                 }
 502
 503                 [Test]
 504                 public void Read_ContentIncluded ()
 505                 {
 506                         var obj = new ContentIncludedClass () { Content = "foo" };
 507                         var r = new XamlObjectReader (obj);
 508                         Read_ContentIncluded (r);
 509                 }
 510
 511                 [Test]
 512                 public void Read_PropertyDefinition ()
 513                 {
 514                         var obj = new PropertyDefinition () { Modifier = "protected", Name = "foo", Type = XamlLanguage.String };
 515                         var r = new XamlObjectReader (obj);
 516                         Read_PropertyDefinition (r);
 517                 }
 518
 519                 [Test]
 520                 public void Read_StaticExtensionWrapper ()
 521                 {
 522                         var obj = new StaticExtensionWrapper () { Param = new StaticExtension ("StaticExtensionWrapper.Foo") };
 523                         var r = new XamlObjectReader (obj);
 524                         Read_StaticExtensionWrapper (r);
 525                 }
 526
 527                 [Test]
 528                 public void Read_TypeExtensionWrapper ()
 529                 {
 530                         var obj = new TypeExtensionWrapper () { Param = new TypeExtension ("Foo") };
 531                         var r = new XamlObjectReader (obj);
 532                         Read_TypeExtensionWrapper (r);
 533                 }
 534         }
 535 }