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