mcs/class/System.Xaml/Test/System.Xaml.Schema/XamlTypeNameTest.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.Reflection;
  27 using System.Text;
  28 using System.Xaml;
  29 using System.Xaml.Schema;
  30 using System.Xml;
  31 using NUnit.Framework;
  32
  33 namespace MonoTests.System.Xaml.Schema
  34 {
  35         [TestFixture]
  36         public class XamlTypeNameTest
  37         {
  38                 [Test]
  39                 public void ConstructorDefault ()
  40                 {
  41                         new XamlTypeName ();
  42                 }
  43
  44                 [Test]
  45                 [ExpectedException (typeof (ArgumentNullException))]
  46                 public void ConstructorXamlTypeNull ()
  47                 {
  48                         new XamlTypeName (null);
  49                 }
  50
  51                 [Test]
  52                 public void ConstructorNameNull ()
  53                 {
  54                         // allowed.
  55                         new XamlTypeName ("urn:foo", null);
  56                 }
  57
  58                 [Test]
  59                 public void ConstructorNamespaceNull ()
  60                 {
  61                         // allowed.
  62                         new XamlTypeName (null, "FooBar");
  63                 }
  64
  65                 [Test]
  66                 public void ConstructorName ()
  67                 {
  68                         var n = new XamlTypeName ("urn:foo", "FooBar");
  69                         Assert.IsNotNull (n.TypeArguments, "#1");
  70                         Assert.AreEqual (0, n.TypeArguments.Count, "#2");
  71                 }
  72
  73                 [Test]
  74                 public void ConstructorTypeArgumentsNull ()
  75                 {
  76                         var n = new XamlTypeName ("urn:foo", "FooBar", (XamlTypeName []) null);
  77                         Assert.IsNotNull (n.TypeArguments, "#1");
  78                         Assert.AreEqual (0, n.TypeArguments.Count, "#2");
  79                 }
  80
  81                 [Test]
  82                 [Ignore (".NET causes NRE on ToString(). It is not really intended and should raise an error")]
  83                 public void ConstructorTypeArgumentsNullEntry ()
  84                 {
  85                         new XamlTypeName ("urn:foo", "FooBar", new XamlTypeName [] {null});
  86                 }
  87
  88                 [Test]
  89                 public void ConstructorTypeArguments ()
  90                 {
  91                         new XamlTypeName ("urn:foo", "FooBar", new XamlTypeName [] {new XamlTypeName ("urn:bar", "FooBarBaz")});
  92                 }
  93
  94                 [Test]
  95                 public void ConstructorTypeArgumentsEmpty ()
  96                 {
  97                         var n = new XamlTypeName ("urn:foo", "FooBar", new XamlTypeName [0]);
  98                         Assert.IsNotNull (n.TypeArguments, "#1");
  99                         Assert.AreEqual (0, n.TypeArguments.Count, "#2");
 100                 }
 101
 102                 [Test]
 103                 [ExpectedException (typeof (InvalidOperationException))]
 104                 public void ToStringDefault ()
 105                 {
 106                         var n = new XamlTypeName ();
 107                         n.ToString ();
 108                 }
 109
 110                 [Test]
 111                 [ExpectedException (typeof (InvalidOperationException))]
 112                 public void ToStringNameNull ()
 113                 {
 114                         var n = new XamlTypeName ("urn:foo", null);
 115                         n.ToString ();
 116                 }
 117
 118                 [Test]
 119                 [ExpectedException (typeof (InvalidOperationException))]
 120                 public void ToStringNamespaceNull ()
 121                 {
 122                         // allowed.
 123                         var n = new XamlTypeName (null, "FooBar");
 124                         n.ToString ();
 125                 }
 126
 127                 [Test]
 128                 public void ToStringTypeArgumentsNull ()
 129                 {
 130                         var n = new XamlTypeName ("urn:foo", "FooBar", (XamlTypeName []) null);
 131                         Assert.AreEqual ("{urn:foo}FooBar", n.ToString (), "#1");
 132                 }
 133
 134                 [Test]
 135                 [Ignore (".NET raises NRE")]
 136                 public void ToStringTypeArgumentsNullEntry ()
 137                 {
 138                         var n = new XamlTypeName ("urn:foo", "FooBar", new XamlTypeName [] {null, new XamlTypeName ("urn:bar", "FooBarBaz")});
 139                         Assert.AreEqual ("{urn:foo}FooBar()", n.ToString (), "#1");
 140                 }
 141
 142                 [Test]
 143                 public void ToStringTypeArguments ()
 144                 {
 145                         var n = new XamlTypeName ("urn:foo", "FooBar", new XamlTypeName [] {new XamlTypeName ("urn:bar", "FooBarBaz")});
 146                         Assert.AreEqual ("{urn:foo}FooBar({urn:bar}FooBarBaz)", n.ToString (), "#1");
 147                 }
 148
 149                 [Test]
 150                 public void ToStringTypeArguments2 ()
 151                 {
 152                         var n = new XamlTypeName ("urn:foo", "Foo", new XamlTypeName [] {new XamlTypeName ("urn:bar", "Bar"), new XamlTypeName ("urn:baz", "Baz")});
 153                         Assert.AreEqual ("{urn:foo}Foo({urn:bar}Bar, {urn:baz}Baz)", n.ToString (), "#1");
 154                 }
 155
 156                 [Test]
 157                 public void ToStringEmptyNamespace ()
 158                 {
 159                         var n = new XamlTypeName (string.Empty, "Foo");
 160                         Assert.AreEqual ("{}Foo", n.ToString (), "#1");
 161                 }
 162
 163                 [Test]
 164                 public void ToStringXamlTypePredefined ()
 165                 {
 166                         var n = new XamlTypeName (XamlLanguage.Int32);
 167                         Assert.AreEqual ("{http://schemas.microsoft.com/winfx/2006/xaml}Int32", n.ToString (), "#1");
 168                 }
 169
 170                 [Test]
 171                 [ExpectedException (typeof (InvalidOperationException))]
 172                 public void ToStringNamespaceLookupInsufficient ()
 173                 {
 174                         var n = new XamlTypeName ("urn:foo", "Foo", new XamlTypeName [] {new XamlTypeName ("urn:bar", "Bar"), new XamlTypeName ("urn:baz", "Baz")});
 175                         var lookup = new MyNamespaceLookup ();
 176                         lookup.Add ("a", "urn:foo");
 177                         lookup.Add ("c", "urn:baz");
 178                         // it fails because there is missing mapping for urn:bar.
 179                         Assert.AreEqual ("a:Foo({urn:bar}Bar, c:Baz)", n.ToString (lookup), "#1");
 180                 }
 181
 182                 [Test]
 183                 public void ToStringNullLookup ()
 184                 {
 185                         var n = new XamlTypeName ("urn:foo", "Foo", new XamlTypeName [] {new XamlTypeName ("urn:bar", "Bar"), new XamlTypeName ("urn:baz", "Baz")});
 186                         Assert.AreEqual ("{urn:foo}Foo({urn:bar}Bar, {urn:baz}Baz)", n.ToString (null), "#1");
 187                 }
 188
 189                 [Test]
 190                 public void ToStringNamespaceLookup ()
 191                 {
 192                         var n = new XamlTypeName ("urn:foo", "Foo", new XamlTypeName [] {new XamlTypeName ("urn:bar", "Bar"), new XamlTypeName ("urn:baz", "Baz")});
 193                         var lookup = new MyNamespaceLookup ();
 194                         lookup.Add ("a", "urn:foo");
 195                         lookup.Add ("b", "urn:bar");
 196                         lookup.Add ("c", "urn:baz");
 197                         Assert.AreEqual ("a:Foo(b:Bar, c:Baz)", n.ToString (lookup), "#1");
 198                         Assert.AreEqual ("b:Bar, c:Baz", XamlTypeName.ToString (n.TypeArguments, lookup), "#2");
 199                 }
 200
 201                 [Test]
 202                 [ExpectedException (typeof (ArgumentNullException))]
 203                 public void StaticToStringNullLookup ()
 204                 {
 205                         XamlTypeName.ToString (new XamlTypeName [] {new XamlTypeName ("urn:foo", "bar")}, null);
 206                 }
 207
 208                 [Test]
 209                 [ExpectedException (typeof (ArgumentNullException))]
 210                 public void StaticToStringNullTypeNameList ()
 211                 {
 212                         XamlTypeName.ToString (null, new MyNamespaceLookup ());
 213                 }
 214
 215                 [Test]
 216                 public void StaticToStringEmptyArray ()
 217                 {
 218                         Assert.AreEqual ("", XamlTypeName.ToString (new XamlTypeName [0], new MyNamespaceLookup ()), "#1");
 219                 }
 220
 221                 class MyNamespaceLookup : INamespacePrefixLookup
 222                 {
 223                         Dictionary<string,string> dic = new Dictionary<string,string> ();
 224
 225                         public void Add (string prefix, string ns)
 226                         {
 227                                 dic [ns] = prefix;
 228                         }
 229
 230                         public string LookupPrefix (string ns)
 231                         {
 232                                 string p;
 233                                 return dic.TryGetValue (ns, out p) ? p : null;
 234                         }
 235                 }
 236
 237                 XamlTypeName dummy;
 238
 239                 [Test]
 240                 [ExpectedException (typeof (ArgumentNullException))]
 241                 public void TryParseNullName ()
 242                 {
 243                         XamlTypeName.TryParse (null, new MyNSResolver (), out dummy);
 244                 }
 245
 246                 [Test]
 247                 [ExpectedException (typeof (ArgumentNullException))]
 248                 public void TryParseNullResolver ()
 249                 {
 250                         XamlTypeName.TryParse ("Foo", null, out dummy);
 251                 }
 252
 253                 [Test]
 254                 public void TryParseEmptyName ()
 255                 {
 256                         Assert.IsFalse (XamlTypeName.TryParse (String.Empty, new MyNSResolver (), out dummy), "#1");
 257                 }
 258
 259                 [Test]
 260                 public void TryParseColon ()
 261                 {
 262                         var r = new MyNSResolver ();
 263                         r.Add ("a", "urn:foo");
 264                         Assert.IsFalse (XamlTypeName.TryParse (":", r, out dummy), "#1");
 265                         Assert.IsFalse (XamlTypeName.TryParse ("a:", r, out dummy), "#2");
 266                         Assert.IsFalse (XamlTypeName.TryParse (":b", r, out dummy), "#3");
 267                 }
 268
 269                 [Test]
 270                 public void TryParseInvalidName ()
 271                 {
 272                         var r = new MyNSResolver ();
 273                         r.Add ("a", "urn:foo");
 274                         r.Add ("#", "urn:bar");
 275                         Assert.IsFalse (XamlTypeName.TryParse ("$%#___!", r, out dummy), "#1");
 276                         Assert.IsFalse (XamlTypeName.TryParse ("a:#$#", r, out dummy), "#2");
 277                         Assert.IsFalse (XamlTypeName.TryParse ("#:foo", r, out dummy), "#3");
 278                 }
 279
 280                 [Test]
 281                 public void TryParseNoFillEmpty ()
 282                 {
 283                         Assert.IsFalse (XamlTypeName.TryParse ("Foo", new MyNSResolver (true), out dummy), "#1");
 284                 }
 285
 286                 [Test]
 287                 public void TryParseFillEmpty ()
 288                 {
 289                         var r = new MyNSResolver ();
 290                         Assert.IsTrue (XamlTypeName.TryParse ("Foo", r, out dummy), "#1");
 291                         Assert.IsNotNull (dummy, "#2");
 292                         Assert.AreEqual (String.Empty, dummy.Namespace, "#2-2");
 293                         Assert.AreEqual ("Foo", dummy.Name, "#2-3");
 294                 }
 295
 296                 [Test]
 297                 public void TryParseAlreadyQualified ()
 298                 {
 299                         Assert.IsFalse (XamlTypeName.TryParse ("{urn:foo}Foo", new MyNSResolver (), out dummy), "#1");
 300                 }
 301
 302                 [Test]
 303                 public void TryParseResolveFailure ()
 304                 {
 305                         Assert.IsFalse (XamlTypeName.TryParse ("x:Foo", new MyNSResolver (), out dummy), "#1");
 306                 }
 307
 308                 [Test]
 309                 public void TryParseResolveSuccess ()
 310                 {
 311                         var r = new MyNSResolver ();
 312                         r.Add ("x", "urn:foo");
 313                         Assert.IsTrue (XamlTypeName.TryParse ("x:Foo", r, out dummy), "#1");
 314                         Assert.IsNotNull (dummy, "#2");
 315                         Assert.AreEqual ("urn:foo", dummy.Namespace, "#2-2");
 316                         Assert.AreEqual ("Foo", dummy.Name, "#2-3");
 317                 }
 318
 319                 [Test]
 320                 public void TryParseInvalidGenericName ()
 321                 {
 322                         var r = new MyNSResolver ();
 323                         r.Add ("x", "urn:foo");
 324                         Assert.IsFalse (XamlTypeName.TryParse ("x:Foo()", r, out dummy), "#1");
 325                 }
 326
 327                 [Test]
 328                 public void TryParseGenericName ()
 329                 {
 330                         var r = new MyNSResolver ();
 331                         r.Add ("x", "urn:foo");
 332                         Assert.IsTrue (XamlTypeName.TryParse ("x:Foo(x:Foo,x:Bar)", r, out dummy), "#1");
 333                         Assert.AreEqual (2, dummy.TypeArguments.Count, "#2");
 334                 }
 335
 336                 [Test]
 337                 [ExpectedException (typeof (ArgumentNullException))]
 338                 public void ParseListNullNames ()
 339                 {
 340                         XamlTypeName.ParseList (null, new MyNSResolver ());
 341                 }
 342
 343                 [Test]
 344                 [ExpectedException (typeof (ArgumentNullException))]
 345                 public void ParseListNullResolver ()
 346                 {
 347                         XamlTypeName.ParseList ("foo", null);
 348                 }
 349
 350                 [Test]
 351                 [ExpectedException (typeof (FormatException))]
 352                 public void ParseListInvalid ()
 353                 {
 354                         XamlTypeName.ParseList ("foo bar", new MyNSResolver ());
 355                 }
 356
 357                 [Test]
 358                 [ExpectedException (typeof (FormatException))]
 359                 public void ParseListInvalid2 ()
 360                 {
 361                         XamlTypeName.ParseList ("foo,", new MyNSResolver ());
 362                 }
 363
 364                 [Test]
 365                 [ExpectedException (typeof (FormatException))]
 366                 public void ParseListInvalid3 ()
 367                 {
 368                         XamlTypeName.ParseList ("", new MyNSResolver ());
 369                 }
 370
 371                 [Test]
 372                 public void ParseListValid ()
 373                 {
 374                         var l = XamlTypeName.ParseList ("foo,  bar", new MyNSResolver ());
 375                         Assert.AreEqual (2, l.Count, "#1");
 376                         Assert.AreEqual ("{}foo", l [0].ToString (), "#2");
 377                         Assert.AreEqual ("{}bar", l [1].ToString (), "#3");
 378                         l = XamlTypeName.ParseList ("foo,bar", new MyNSResolver ());
 379                         Assert.AreEqual ("{}foo", l [0].ToString (), "#4");
 380                         Assert.AreEqual ("{}bar", l [1].ToString (), "#5");
 381                 }
 382
 383                 class MyNSResolver : IXamlNamespaceResolver
 384                 {
 385                         public MyNSResolver ()
 386                                 : this (false)
 387                         {
 388                         }
 389
 390                         public MyNSResolver (bool returnNullForEmpty)
 391                         {
 392                                 if (!returnNullForEmpty)
 393                                         dic.Add (String.Empty, String.Empty);
 394                         }
 395
 396                         Dictionary<string,string> dic = new Dictionary<string,string> ();
 397
 398                         public void Add (string prefix, string ns)
 399                         {
 400                                 dic [prefix] = ns;
 401                         }
 402
 403                         public string GetNamespace (string prefix)
 404                         {
 405                                 string ns;
 406                                 return dic.TryGetValue (prefix, out ns) ? ns : null;
 407                         }
 408
 409                         public IEnumerable<NamespaceDeclaration> GetNamespacePrefixes ()
 410                         {
 411                                 foreach (var p in dic)
 412                                         yield return new NamespaceDeclaration (p.Value, p.Key);
 413                         }
 414                 }
 415         }
 416 }