mcs/class/System.Xaml/Test/System.Xaml/XamlXmlReaderTest.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.Globalization;
  28 using System.IO;
  29 using System.Linq;
  30 using System.Reflection;
  31 using System.Windows.Markup;
  32 using System.Xaml;
  33 using System.Xaml.Schema;
  34 using System.Xml;
  35 using NUnit.Framework;
  36
  37 using CategoryAttribute = NUnit.Framework.CategoryAttribute;
  38
  39 namespace MonoTests.System.Xaml
  40 {
  41         [TestFixture]
  42         public class XamlXmlReaderTest : XamlReaderTestBase
  43         {
  44                 // read test
  45
  46                 XamlReader GetReader (string filename)
  47                 {
  48                         return new XamlXmlReader (XmlReader.Create (Path.Combine ("Test/XmlFiles", filename), new XmlReaderSettings () { CloseInput =true }));
  49                 }
  50
  51                 void ReadTest (string filename)
  52                 {
  53                         var r = GetReader (filename);
  54                         while (!r.IsEof)
  55                                 r.Read ();
  56                 }
  57
  58                 T LoadTest<T> (string filename)
  59                 {
  60                         Type type = typeof (T);
  61                         var obj = XamlServices.Load (GetReader (filename));
  62                         Assert.AreEqual (type, obj.GetType (), "type");
  63                         return (T) obj;
  64                 }
  65
  66                 [Test]
  67                 public void SchemaContext ()
  68                 {
  69                         Assert.AreNotEqual (XamlLanguage.Type.SchemaContext, new XamlXmlReader (XmlReader.Create (new StringReader ("<root/>"))).SchemaContext, "#1");
  70                 }
  71
  72                 [Test]
  73                 public void Read_Int32 ()
  74                 {
  75                         ReadTest ("Int32.xml");
  76                         var ret = LoadTest<int> ("Int32.xml");
  77                         Assert.AreEqual (5, ret, "ret");
  78                 }
  79
  80                 [Test]
  81                 public void Read_DateTime ()
  82                 {
  83                         ReadTest ("DateTime.xml");
  84                         var ret = LoadTest<DateTime> ("DateTime.xml");
  85                         Assert.AreEqual (new DateTime (2010, 4, 14), ret, "ret");
  86                 }
  87
  88                 [Test]
  89                 public void Read_TimeSpan ()
  90                 {
  91                         ReadTest ("TimeSpan.xml");
  92                         var ret = LoadTest<TimeSpan> ("TimeSpan.xml");
  93                         Assert.AreEqual (TimeSpan.FromMinutes (7), ret, "ret");
  94                 }
  95
  96                 [Test]
  97                 public void Read_ArrayInt32 ()
  98                 {
  99                         ReadTest ("Array_Int32.xml");
 100                         var ret = LoadTest<int[]> ("Array_Int32.xml");
 101                         Assert.AreEqual (5, ret.Length, "#1");
 102                         Assert.AreEqual (2147483647, ret [4], "#2");
 103                 }
 104
 105                 [Test]
 106                 public void Read_DictionaryInt32String ()
 107                 {
 108                         ReadTest ("Dictionary_Int32_String.xml");
 109                         //LoadTest<Dictionary<int,string>> ("Dictionary_Int32_String.xml");
 110                 }
 111
 112                 [Test]
 113                 public void Read_DictionaryStringType ()
 114                 {
 115                         ReadTest ("Dictionary_String_Type.xml");
 116                         //LoadTest<Dictionary<string,Type>> ("Dictionary_String_Type.xml");
 117                 }
 118
 119                 [Test]
 120                 public void Read_SilverlightApp1 ()
 121                 {
 122                         ReadTest ("SilverlightApp1.xaml");
 123                 }
 124
 125                 [Test]
 126                 public void Read_Guid ()
 127                 {
 128                         ReadTest ("Guid.xml");
 129                         var ret = LoadTest<Guid> ("Guid.xml");
 130                         Assert.AreEqual (Guid.Parse ("9c3345ec-8922-4662-8e8d-a4e41f47cf09"), ret, "ret");
 131                 }
 132
 133                 [Test]
 134                 public void Read_GuidFactoryMethod ()
 135                 {
 136                         ReadTest ("GuidFactoryMethod.xml");
 137                         //var ret = LoadTest<Guid> ("GuidFactoryMethod.xml");
 138                         //Assert.AreEqual (Guid.Parse ("9c3345ec-8922-4662-8e8d-a4e41f47cf09"), ret, "ret");
 139                 }
 140
 141                 [Test]
 142                 public void ReadInt32Details ()
 143                 {
 144                         var r = GetReader ("Int32.xml");
 145
 146                         Assert.IsTrue (r.Read (), "ns#1");
 147                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2");
 148                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns#3");
 149
 150                         Assert.IsTrue (r.Read (), "so#1");
 151                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2");
 152                         Assert.AreEqual (XamlLanguage.Int32, r.Type, "so#3");
 153
 154                         ReadBase (r);
 155
 156                         Assert.IsTrue (r.Read (), "sinit#1");
 157                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sinit#2");
 158                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "sinit#3");
 159
 160                         Assert.IsTrue (r.Read (), "vinit#1");
 161                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vinit#2");
 162                         Assert.AreEqual ("5", r.Value, "vinit#3"); // string
 163
 164                         Assert.IsTrue (r.Read (), "einit#1");
 165                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "einit#2");
 166
 167                         Assert.IsTrue (r.Read (), "eo#1");
 168                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2");
 169
 170                         Assert.IsFalse (r.Read (), "end");
 171                 }
 172
 173                 [Test]
 174                 public void ReadDateTimeDetails ()
 175                 {
 176                         var r = GetReader ("DateTime.xml");
 177
 178                         Assert.IsTrue (r.Read (), "ns#1");
 179                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2");
 180                         Assert.AreEqual ("clr-namespace:System;assembly=mscorlib", r.Namespace.Namespace, "ns#3");
 181
 182                         Assert.IsTrue (r.Read (), "so#1");
 183                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2");
 184                         Assert.AreEqual (r.SchemaContext.GetXamlType (typeof (DateTime)), r.Type, "so#3");
 185
 186                         ReadBase (r);
 187
 188                         Assert.IsTrue (r.Read (), "sinit#1");
 189                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sinit#2");
 190                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "sinit#3");
 191
 192                         Assert.IsTrue (r.Read (), "vinit#1");
 193                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vinit#2");
 194                         Assert.AreEqual ("2010-04-14", r.Value, "vinit#3"); // string
 195
 196                         Assert.IsTrue (r.Read (), "einit#1");
 197                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "einit#2");
 198
 199                         Assert.IsTrue (r.Read (), "eo#1");
 200                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2");
 201                         Assert.IsFalse (r.Read (), "end");
 202                 }
 203
 204                 [Test]
 205                 public void ReadGuidFactoryMethodDetails ()
 206                 {
 207                         var r = GetReader ("GuidFactoryMethod.xml");
 208
 209                         Assert.IsTrue (r.Read (), "ns#1");
 210                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2");
 211                         Assert.AreEqual ("clr-namespace:System;assembly=mscorlib", r.Namespace.Namespace, "ns#3");
 212                         Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#4");
 213
 214                         Assert.IsTrue (r.Read (), "ns2#1");
 215                         Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns2#2");
 216                         Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ns2#3");
 217                         Assert.AreEqual ("x", r.Namespace.Prefix, "ns2#4");
 218
 219                         Assert.IsTrue (r.Read (), "so#1");
 220                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "so#2");
 221                         var xt = r.SchemaContext.GetXamlType (typeof (Guid));
 222                         Assert.AreEqual (xt, r.Type, "so#3");
 223
 224                         ReadBase (r);
 225
 226                         Assert.IsTrue (r.Read (), "sfactory#1");
 227                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sfactory#2");
 228                         Assert.AreEqual (XamlLanguage.FactoryMethod, r.Member, "sfactory#3");
 229
 230                         Assert.IsTrue (r.Read (), "vfactory#1");
 231                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vfactory#2");
 232                         Assert.AreEqual ("Parse", r.Value, "vfactory#3"); // string
 233
 234                         Assert.IsTrue (r.Read (), "efactory#1");
 235                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "efactory#2");
 236
 237                         Assert.IsTrue (r.Read (), "sarg#1");
 238                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sarg#2");
 239                         Assert.AreEqual (XamlLanguage.Arguments, r.Member, "sarg#3");
 240
 241                         Assert.IsTrue (r.Read (), "sarg1#1");
 242                         Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "sarg1#2");
 243                         Assert.AreEqual (XamlLanguage.String, r.Type, "sarg1#3");
 244
 245                         Assert.IsTrue (r.Read (), "sInit#1");
 246                         Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sInit#2");
 247                         Assert.AreEqual (XamlLanguage.Initialization, r.Member, "sInit#3");
 248
 249                         Assert.IsTrue (r.Read (), "varg1#1");
 250                         Assert.AreEqual (XamlNodeType.Value, r.NodeType, "varg1#2");
 251                         Assert.AreEqual ("9c3345ec-8922-4662-8e8d-a4e41f47cf09", r.Value, "varg1#3");
 252
 253                         Assert.IsTrue (r.Read (), "eInit#1");
 254                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "eInit#2");
 255
 256                         Assert.IsTrue (r.Read (), "earg1#1");
 257                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "earg1#2");
 258
 259                         Assert.IsTrue (r.Read (), "earg#1");
 260                         Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "earg#2");
 261
 262
 263                         Assert.IsTrue (r.Read (), "eo#1");
 264                         Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "eo#2");
 265
 266                         Assert.IsFalse (r.Read (), "end");
 267                 }
 268
 269                 [Test]
 270                 public void Read_String ()
 271                 {
 272                         var r = GetReader ("String.xml");
 273                         Read_String (r);
 274                         var ret = LoadTest<string> ("String.xml");
 275                         Assert.AreEqual ("foo", ret, "ret");
 276                 }
 277
 278                 [Test]
 279                 public void WriteNullMemberAsObject ()
 280                 {
 281                         var r = GetReader ("TestClass4.xml");
 282                         WriteNullMemberAsObject (r, null);
 283                 }
 284
 285                 [Test]
 286                 public void StaticMember ()
 287                 {
 288                         var r = GetReader ("TestClass5.xml");
 289                         StaticMember (r);
 290                 }
 291
 292                 [Test]
 293                 public void Skip ()
 294                 {
 295                         var r = GetReader ("String.xml");
 296                         Skip (r);
 297                 }
 298
 299                 [Test]
 300                 public void Skip2 ()
 301                 {
 302                         var r = GetReader ("String.xml");
 303                         Skip2 (r);
 304                 }
 305
 306                 [Test]
 307                 public void Read_XmlDocument ()
 308                 {
 309                         var doc = new XmlDocument ();
 310                         doc.LoadXml ("<root xmlns='urn:foo'><elem attr='val' /></root>");
 311                         // note that corresponding XamlXmlWriter is untested yet.
 312                         var r = GetReader ("XmlDocument.xml");
 313                         Read_XmlDocument (r);
 314                 }
 315
 316                 [Test]
 317                 public void Read_NonPrimitive ()
 318                 {
 319                         var r = GetReader ("NonPrimitive.xml");
 320                         Read_NonPrimitive (r);
 321                 }
 322
 323                 [Test]
 324                 public void Read_TypeExtension ()
 325                 {
 326                         var r = GetReader ("Type.xml");
 327                         Read_TypeOrTypeExtension (r, null, XamlLanguage.Type.GetMember ("Type"));
 328                 }
 329
 330                 [Test]
 331                 public void Read_Type2 ()
 332                 {
 333                         var r = GetReader ("Type2.xml");
 334                         Read_TypeOrTypeExtension2 (r, null, XamlLanguage.Type.GetMember ("Type"));
 335                 }
 336
 337                 [Test]
 338                 public void Read_Reference ()
 339                 {
 340                         var r = GetReader ("Reference.xml");
 341                         Read_Reference (r);
 342                         var ret = XamlServices.Load (GetReader ("Reference.xml"));
 343                         Assert.IsNotNull (ret, "#1"); // the returned value is however not a Reference (in .NET 4.0 it is MS.Internal.Xaml.Context.NameFixupToken).
 344                 }
 345
 346                 [Test]
 347                 public void Read_Null ()
 348                 {
 349                         var r = GetReader ("NullExtension.xml");
 350                         Read_NullOrNullExtension (r, null);
 351                         Assert.IsNull (XamlServices.Load (GetReader ("NullExtension.xml")));
 352                 }
 353
 354                 [Test]
 355                 public void Read_StaticExtension ()
 356                 {
 357                         var r = GetReader ("StaticExtension.xml");
 358                         Read_StaticExtension (r, XamlLanguage.Static.GetMember ("Member"));
 359                 }
 360
 361                 [Test]
 362                 public void Read_ListInt32 ()
 363                 {
 364                         var r = GetReader ("List_Int32.xml");
 365                         Read_ListInt32 (r, null, new int [] {5, -3, int.MaxValue, 0}.ToList ());
 366                         var ret = LoadTest<List<int>> ("List_Int32.xml");
 367                         Assert.AreEqual (4, ret.Count, "#1");
 368                         Assert.AreEqual (2147483647, ret [2], "#2");
 369                 }
 370
 371                 [Test]
 372                 public void Read_ListInt32_2 ()
 373                 {
 374                         var r = GetReader ("List_Int32_2.xml");
 375                         Read_ListInt32 (r, null, new int [0].ToList ());
 376                 }
 377
 378                 [Test]
 379                 public void Read_ArrayList ()
 380                 {
 381                         var r = GetReader ("ArrayList.xml");
 382                         Read_ArrayList (r);
 383                 }
 384
 385                 [Test]
 386                 public void Read_Array ()
 387                 {
 388                         var r = GetReader ("ArrayExtension.xml");
 389                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, null, typeof (ArrayExtension));
 390                 }
 391
 392                 [Test]
 393                 public void Read_MyArrayExtension ()
 394                 {
 395                         var r = GetReader ("MyArrayExtension.xml");
 396                         Read_ArrayOrArrayExtensionOrMyArrayExtension (r, null, typeof (MyArrayExtension));
 397                 }
 398
 399                 [Test]
 400                 public void Read_ArrayExtension2 ()
 401                 {
 402                         var r = GetReader ("ArrayExtension2.xml");
 403                         Read_ArrayExtension2 (r);
 404                 }
 405
 406                 [Test]
 407                 public void Read_CustomMarkupExtension ()
 408                 {
 409                         var r = GetReader ("MyExtension.xml");
 410                         Read_CustomMarkupExtension (r);
 411                 }
 412
 413                 [Test]
 414                 public void Read_CustomMarkupExtension2 ()
 415                 {
 416                         var r = GetReader ("MyExtension2.xml");
 417                         Read_CustomMarkupExtension2 (r);
 418                 }
 419
 420                 [Test]
 421                 public void Read_CustomMarkupExtension3 ()
 422                 {
 423                         var r = GetReader ("MyExtension3.xml");
 424                         Read_CustomMarkupExtension3 (r);
 425                 }
 426
 427                 [Test]
 428                 public void Read_CustomMarkupExtension4 ()
 429                 {
 430                         var r = GetReader ("MyExtension4.xml");
 431                         Read_CustomMarkupExtension4 (r);
 432                 }
 433
 434                 [Test]
 435                 public void Read_CustomMarkupExtension6 ()
 436                 {
 437                         var r = GetReader ("MyExtension6.xml");
 438                         Read_CustomMarkupExtension6 (r);
 439                 }
 440
 441                 [Test]
 442                 public void Read_Dictionary ()
 443                 {
 444                         var obj = new Dictionary<string,object> ();
 445                         obj ["Foo"] = 5.0;
 446                         obj ["Bar"] = -6.5;
 447                         var r = GetReader ("Dictionary_String_Double.xml");
 448                         Read_Dictionary (r);
 449                 }
 450
 451                 [Test]
 452                 public void Read_Dictionary2 ()
 453                 {
 454                         var obj = new Dictionary<string,Type> ();
 455                         obj ["Foo"] = typeof (int);
 456                         obj ["Bar"] = typeof (Dictionary<Type,XamlType>);
 457                         var r = GetReader ("Dictionary_String_Type_2.xml");
 458                         Read_Dictionary2 (r, XamlLanguage.Type.GetMember ("Type"));
 459                 }
 460
 461                 [Test]
 462                 public void PositionalParameters2 ()
 463                 {
 464                         var r = GetReader ("PositionalParametersWrapper.xml");
 465                         PositionalParameters2 (r);
 466                 }
 467
 468                 [Test]
 469                 public void ComplexPositionalParameters ()
 470                 {
 471                         var r = GetReader ("ComplexPositionalParameterWrapper.xml");
 472                         ComplexPositionalParameters (r);
 473                 }
 474
 475                 [Test]
 476                 public void Read_ListWrapper ()
 477                 {
 478                         var r = GetReader ("ListWrapper.xml");
 479                         Read_ListWrapper (r);
 480                 }
 481
 482                 [Test]
 483                 public void Read_ListWrapper2 () // read-write list member.
 484                 {
 485                         var r = GetReader ("ListWrapper2.xml");
 486                         Read_ListWrapper2 (r);
 487                 }
 488
 489                 [Test]
 490                 public void Read_ContentIncluded ()
 491                 {
 492                         var r = GetReader ("ContentIncluded.xml");
 493                         Read_ContentIncluded (r);
 494                 }
 495
 496                 [Test]
 497                 public void Read_PropertyDefinition ()
 498                 {
 499                         var r = GetReader ("PropertyDefinition.xml");
 500                         Read_PropertyDefinition (r);
 501                 }
 502         }
 503 }