mcs/tools/monkeydoc/Test/Monkeydoc.Ecma/EcmaUrlTests.cs

   1 using System;
   2 using System.IO;
   3 using System.Linq;
   4 using System.Collections.Generic;
   5
   6 using NUnit.Framework;
   7
   8 using MonkeyDoc;
   9 using Monkeydoc.Ecma;
  10
  11 namespace MonoTests.MonkeyDoc.Ecma
  12 {
  13         [TestFixture]
  14         public class EcmaUrlTests
  15         {
  16                 EcmaUrlParser parser;
  17
  18                 [SetUp]
  19                 public void Setup ()
  20                 {
  21                         parser = new EcmaUrlParser ();
  22                 }
  23
  24                 void AssertValidUrl (string url)
  25                 {
  26                         try {
  27                                 parser.IsValid (url);
  28                         } catch {
  29                                 Assert.Fail (string.Format ("URL '{0}' deemed not valid", url));
  30                         }
  31                 }
  32
  33                 void AssertInvalidUrl (string url)
  34                 {
  35                         try {
  36                                 parser.IsValid (url);
  37                         } catch {
  38                                 return;
  39                         }
  40                         Assert.Fail (string.Format ("URL '{0}' deemed valid", url));
  41                 }
  42
  43                 void AssertUrlDesc (EcmaDesc expected, string url)
  44                 {
  45                         EcmaDesc actual = null;
  46                         try {
  47                                 actual = parser.Parse (url);
  48                         } catch (Exception e) {
  49                                 Assert.Fail (string.Format ("URL '{0}' deemed not valid: {1}{2}", url, Environment.NewLine, e.ToString ()));
  50                         }
  51
  52                         Assert.AreEqual (expected, actual, "Converted URL differs");
  53                 }
  54
  55                 [Test]
  56                 public void CommonMethodUrlIsValidTest ()
  57                 {
  58                         AssertValidUrl ("M:System.String.FooBar()");
  59                         AssertValidUrl ("M:System.String.FooBar(System.String, Int32)");
  60                         AssertValidUrl ("M:System.Foo.Int32<System.String+FooBar<System.Blop<T, U`2>>>.Foo()");
  61                         AssertValidUrl ("M:System.Foo.Int32<System.String+FooBar<System.Blop<T, U`2>>>.Foo(Bleh,Bar)");
  62                         AssertValidUrl ("M:System.Foo.Int32<System.String+FooBar<System.Blop<T, U`2>>>.Foo(Bleh<V>,Bar)");
  63                         AssertValidUrl ("M:Gendarme.Framework.Helpers.Log.WriteLine(string,string,object[])");
  64                         AssertValidUrl ("M:Mono.Security.X509.Extensions.SubjectKeyIdentifierExtension.Decode");
  65                         AssertValidUrl ("M:Mono.Security.PKCS7.IssuerAndSerialNumber");
  66                 }
  67
  68                 [Test]
  69                 public void CommonTypeUrlIsValidTest ()
  70                 {
  71                         AssertValidUrl ("T:Int32");
  72                         AssertValidUrl ("T:System.Foo.Int32");
  73                         AssertValidUrl ("T:System.Foo.Int32<System.String+FooBar`1>");
  74                         AssertValidUrl ("T:System.Foo.Int32<System.String+FooBar<System.Blop<T, U>>>");
  75                         AssertValidUrl ("T:System.Foo.Int32<T>");
  76                         AssertValidUrl ("T:System.Foo.Int32<T,U>");
  77                         AssertValidUrl ("T:System.Foo.Int32<System.String+FooBar<System.Blop<T, U>>>");
  78                         AssertValidUrl ("T:System.Foo.Int32<System.String+FooBar<System.Blop<T, U`2>>>");
  79                 }
  80
  81                 [Test]
  82                 public void CommonTypeUrlNotValidTest ()
  83                 {
  84                         AssertInvalidUrl ("TInt32");
  85                         AssertInvalidUrl ("K:Int32");
  86                         AssertInvalidUrl ("T:System..Foo.Int32");
  87                         AssertInvalidUrl ("T:System.Foo.Int32<System.String+FooBar`1");
  88                         AssertInvalidUrl ("T:System.Foo.Int32<System.String+FooBarSystem.Blop<T, U>>>");
  89                         AssertInvalidUrl ("T:System.Foo.Int32<T,>");
  90                         AssertInvalidUrl ("T:System.Foo.Int32<+FooBar<System.Blop<T, U>>>");
  91                 }
  92
  93                 [Test]
  94                 public void NamespaceValidTest ()
  95                 {
  96                         AssertValidUrl ("N:Foo.Bar");
  97                         AssertValidUrl ("N:Foo");
  98                         AssertValidUrl ("N:Foo.Bar.Baz");
  99                         AssertValidUrl ("N:A.B.C");
 100
 101                         var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Namespace,
 102                                                     Namespace = "Foo.Bar.Blop" };
 103                         AssertUrlDesc (ast, "N:Foo.Bar.Blop");
 104                 }
 105
 106                 [Test]
 107                 public void ConstructorValidTest ()
 108                 {
 109                         AssertValidUrl ("C:Gendarme.Rules.Concurrency.DecorateThreadsRule.DecorateThreadsRule");
 110                         AssertValidUrl ("C:Gendarme.Rules.Concurrency.DecorateThreadsRule.DecorateThreadsRule()");
 111                         AssertValidUrl ("C:Gendarme.Rules.Concurrency.DecorateThreadsRule.DecorateThreadsRule(System.String)");
 112                         AssertValidUrl ("C:Gendarme.Framework.Helpers.MethodSignature.MethodSignature(string,string,string[],System.Func<Mono.Cecil.MethodReference,System.Boolean>)");
 113                         AssertValidUrl ("C:System.Collections.Generic.Dictionary<TKey,TValue>+KeyCollection.KeyCollection(System.Collections.Generic.Dictionary<TKey,TValue>)");
 114                 }
 115
 116                 [Test]
 117                 public void SlashExpressionValidTest ()
 118                 {
 119                         AssertValidUrl ("T:Foo.Bar.Type/*");
 120                         AssertValidUrl ("T:Foo.Bar.Type/M");
 121                         AssertValidUrl ("T:Gendarme.Framework.Bitmask<T>/M/Equals");
 122                         AssertValidUrl ("T:Gendarme.Framework.Helpers.Log/M/WriteLine<T>");
 123                         AssertValidUrl ("T:System.Windows.Forms.AxHost/M/System.ComponentModel.ICustomTypeDescriptor.GetEvents");
 124                 }
 125
 126                 [Test]
 127                 public void MethodWithArgModValidTest ()
 128                 {
 129                         AssertValidUrl ("M:Foo.Bar.FooBar(int, System.Drawing.Imaging&)");
 130                         AssertValidUrl ("M:Foo.Bar.FooBar(int@, System.Drawing.Imaging)");
 131                         AssertValidUrl ("M:Foo.Bar.FooBar(int, System.Drawing.Imaging*)");
 132                         AssertValidUrl ("M:Foo.Bar.FooBar(int*, System.Drawing.Imaging&)");
 133                         AssertValidUrl ("M:Atk.NoOpObject.GetRunAttributes(int,int&,int&)");
 134                 }
 135
 136                 [Test]
 137                 public void MethodWithJaggedArrayArgsValidTest ()
 138                 {
 139                         AssertValidUrl ("M:System.Reflection.Emit.SignatureHelper.GetPropertySigHelper(System.Reflection.Module,System.Reflection.CallingConventions,Type,Type[],Type[],Type[],Type[][],Type[][])");
 140                 }
 141
 142                 [Test]
 143                 public void MethodWithInnerTypeValidTest ()
 144                 {
 145                         AssertValidUrl ("M:System.TimeZoneInfo+AdjustmentRule.CreateAdjustmentRule");
 146                 }
 147
 148                 [Test]
 149                 public void FieldValidTest ()
 150                 {
 151                         AssertValidUrl ("F:Mono.Terminal.Curses.KeyF10");
 152                         AssertValidUrl ("F:Novell.Directory.Ldap.Utilclass.ExceptionMessages.NOT_IMPLEMENTED");
 153                         AssertValidUrl ("F:Novell.Directory.Ldap.LdapException.NOT_ALLOWED_ON_NONLEAF");
 154                 }
 155
 156                 [Test]
 157                 public void PropertyValidTest ()
 158                 {
 159                         AssertValidUrl ("P:System.Foo.Bar");
 160                         AssertValidUrl ("P:System.ArraySegment<T>.Array");
 161                 }
 162
 163                 [Test]
 164                 public void IndexPropertyValidTest ()
 165                 {
 166                         AssertValidUrl ("P:System.ComponentModel.PropertyDescriptorCollection.Item(int)");
 167                         AssertValidUrl ("P:System.ComponentModel.AttributeCollection.Item(Type)");
 168                         AssertValidUrl ("P:System.Web.SessionState.HttpSessionStateContainer$System.Web.SessionState.IHttpSessionState.Item(System.Int32)");
 169                         AssertValidUrl ("P:System.Collections.Specialized.BitVector32.Item(System.Collections.Specialized.BitVector32+Section)");
 170                 }
 171
 172                 [Test]
 173                 public void ExplicitMethodImplValidTest ()
 174                 {
 175                         AssertValidUrl ("M:Microsoft.Win32.RegistryKey$System.IDisposable.Dispose");
 176                 }
 177
 178                 [Test]
 179                 public void MetaEtcNodeTest ()
 180                 {
 181                         var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Type,
 182                                                     Namespace = "Foo.Bar",
 183                                                     TypeName = "Type",
 184                                                     Etc = '*' };
 185                         AssertUrlDesc (ast, "T:Foo.Bar.Type/*");
 186                 }
 187
 188                 [Test]
 189                 public void MetaEtcWithInnerTypeTest ()
 190                 {
 191                         var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Type,
 192                                                     Namespace = "Novell.Directory.Ldap",
 193                                                     TypeName = "Connection",
 194                                                     NestedType = new EcmaDesc { DescKind = EcmaDesc.Kind.Type, TypeName = "ReaderThread" },
 195                                                     Etc = '*' };
 196                         AssertUrlDesc (ast, "T:Novell.Directory.Ldap.Connection+ReaderThread/*");
 197                 }
 198
 199                 [Test]
 200                 public void SimpleTypeUrlParseTest ()
 201                 {
 202                         var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Type,
 203                                                     TypeName = "String",
 204                                                     Namespace = "System" };
 205                         AssertUrlDesc (ast, "T:System.String");
 206                 }
 207
 208                 [Test]
 209                 public void TypeWithOneGenericUrlParseTest ()
 210                 {
 211                         var generics = new[] {
 212                                 new EcmaDesc {
 213                                         DescKind = EcmaDesc.Kind.Type,
 214                                         Namespace = string.Empty,
 215                                         TypeName = "T"
 216                                 }
 217                         };
 218                         var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Type,
 219                                                     TypeName = "String",
 220                                                     Namespace = "System",
 221                                                     GenericTypeArguments = generics,
 222                         };
 223
 224                         AssertUrlDesc (ast, "T:System.String<T>");
 225                 }
 226
 227                 [Test]
 228                 public void TypeWithNestedGenericUrlParseTest ()
 229                 {
 230                         var generics = new[] {
 231                                 new EcmaDesc {
 232                                         DescKind = EcmaDesc.Kind.Type,
 233                                         TypeName = "T",
 234                                         Namespace = string.Empty
 235                                 },
 236                                 new EcmaDesc {
 237                                         DescKind = EcmaDesc.Kind.Type,
 238                                         Namespace = "System.Collections.Generic",
 239                                         TypeName = "List",
 240                                         GenericTypeArguments = new[] {
 241                                                 new EcmaDesc {
 242                                                         DescKind = EcmaDesc.Kind.Type,
 243                                                         TypeName = "V",
 244                                                         Namespace = string.Empty
 245                                                 }
 246                                         }
 247                                 }
 248                         };
 249                         var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Type,
 250                                                     TypeName = "String",
 251                                                     Namespace = "System",
 252                                                     GenericTypeArguments = generics,
 253                         };
 254
 255                         AssertUrlDesc (ast, "T:System.String<T, System.Collections.Generic.List<V>>");
 256                 }
 257
 258                 [Test]
 259                 public void SimpleMethodUrlParseTest ()
 260                 {
 261                         var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Method,
 262                                                     TypeName = "String",
 263                                                     Namespace = "System",
 264                                                     MemberName = "FooBar"
 265                         };
 266                         AssertUrlDesc (ast, "M:System.String.FooBar()");
 267                 }
 268
 269                 [Test]
 270                 public void MethodWithArgsUrlParseTest ()
 271                 {
 272                         var args = new[] {
 273                                 new EcmaDesc {
 274                                         DescKind = EcmaDesc.Kind.Type,
 275                                         Namespace = "System",
 276                                         TypeName = "String"
 277                                 },
 278                                 new EcmaDesc {
 279                                         DescKind = EcmaDesc.Kind.Type,
 280                                         TypeName = "Int32",
 281                                         Namespace = string.Empty
 282                                 }
 283                         };
 284                         var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Method,
 285                                                     TypeName = "String",
 286                                                     Namespace = "System",
 287                                                     MemberName = "FooBar",
 288                                                     MemberArguments = args
 289                         };
 290                         AssertUrlDesc (ast, "M:System.String.FooBar(System.String, Int32)");
 291                 }
 292
 293                 [Test]
 294                 public void MethodWithArgsAndGenericsUrlParseTest ()
 295                 {
 296                         var args = new[] {
 297                                 new EcmaDesc {
 298                                         DescKind = EcmaDesc.Kind.Type,
 299                                         Namespace = "System",
 300                                         TypeName = "String"
 301                                 },
 302                                 new EcmaDesc {
 303                                         DescKind = EcmaDesc.Kind.Type,
 304                                         Namespace = "System.Collections.Generic",
 305                                         TypeName = "Dictionary",
 306                                         GenericTypeArguments = new[] {
 307                                                 new EcmaDesc {
 308                                                         DescKind = EcmaDesc.Kind.Type,
 309                                                         TypeName = "K",
 310                                                         Namespace = string.Empty
 311                                                 },
 312                                                 new EcmaDesc {
 313                                                         DescKind = EcmaDesc.Kind.Type,
 314                                                         TypeName = "V",
 315                                                         Namespace = string.Empty
 316                                                 }
 317                                         }
 318                                 }
 319                         };
 320
 321                         var generics = new[] {
 322                                 new EcmaDesc {
 323                                         DescKind = EcmaDesc.Kind.Type,
 324                                         TypeName = "Action",
 325                                         Namespace = string.Empty,
 326                                         GenericTypeArguments = new[] {
 327                                                 new EcmaDesc {
 328                                                         DescKind = EcmaDesc.Kind.Type,
 329                                                         Namespace = "System",
 330                                                         TypeName = "Single",
 331                                                 },
 332                                                 new EcmaDesc {
 333                                                         DescKind = EcmaDesc.Kind.Type,
 334                                                         TypeName = "int",
 335                                                         Namespace = string.Empty
 336                                                 },
 337                                         }
 338                                 }
 339                         };
 340
 341                         var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Method,
 342                                                     TypeName = "String",
 343                                                     Namespace = "System",
 344                                                     MemberName = "FooBar",
 345                                                     MemberArguments = args,
 346                                                     GenericMemberArguments = generics
 347                         };
 348                         AssertUrlDesc (ast, "M:System.String.FooBar<Action<System.Single, int>>(System.String, System.Collections.Generic.Dictionary<K, V>)");
 349                 }
 350
 351                 [Test]
 352                 public void ExplicitMethodImplementationParseTest ()
 353                 {
 354                         var inner = new EcmaDesc {
 355                                 MemberName = "Dispose",
 356                                 TypeName = "IDisposable",
 357                                 Namespace = "System"
 358                         };
 359                         var ast = new EcmaDesc {
 360                                 DescKind = EcmaDesc.Kind.Method,
 361                                 TypeName = "RegistryKey",
 362                                 Namespace = "Microsoft.Win32",
 363                                 ExplicitImplMember = inner
 364                         };
 365                         AssertUrlDesc (ast, "M:Microsoft.Win32.RegistryKey$System.IDisposable.Dispose");
 366                 }
 367
 368                 [Test]
 369                 public void SimpleMethodWithNumberInType ()
 370                 {
 371                         var ast = new EcmaDesc {
 372                                 DescKind = EcmaDesc.Kind.Method,
 373                                 TypeName = "ASN1",
 374                                 Namespace = "Mono.Security",
 375                                 MemberName = "Add"
 376                         };
 377                         AssertUrlDesc (ast, "M:Mono.Security.ASN1.Add");
 378                 }
 379
 380                 [Test]
 381                 public void JaggedArrayWithDimensions ()
 382                 {
 383                         var ast = new EcmaDesc {
 384                                 DescKind = EcmaDesc.Kind.Type,
 385                                 TypeName = "Int32",
 386                                 Namespace = "System",
 387                                 ArrayDimensions = new int[] { 3, 1, 1 }
 388                         };
 389                         AssertUrlDesc (ast, "T:System.Int32[,,][][]");
 390                 }
 391
 392                 [Test]
 393                 public void ExplicitIndexerImplementation ()
 394                 {
 395                         var explicitImpl = new EcmaDesc {
 396                                 Namespace = "System.Web.SessionState",
 397                                 TypeName = "IHttpSessionState",
 398                                 MemberName = "Item",
 399                                 MemberArguments = new [] { new EcmaDesc { DescKind = EcmaDesc.Kind.Type, Namespace = "System", TypeName = "Int32" } },
 400                         };
 401                         var ast = new EcmaDesc {
 402                                 DescKind = EcmaDesc.Kind.Property,
 403                                 TypeName = "HttpSessionStateContainer",
 404                                 Namespace = "System.Web.SessionState",
 405                                 ExplicitImplMember = explicitImpl,
 406                         };
 407                         AssertUrlDesc (ast, "P:System.Web.SessionState.HttpSessionStateContainer$System.Web.SessionState.IHttpSessionState.Item(System.Int32)");
 408                 }
 409
 410                 /*              [Test]
 411                 public void TreeParsabilityTest ()
 412                 {
 413                         var rootTree = RootTree.LoadTree ("/home/jeremie/monodoc/");
 414                         Node result;
 415                         var generator = new CheckGenerator ();
 416
 417                         foreach (var leaf in GetLeaves (rootTree.RootNode).Where (IsEcmaNode))
 418                                 AssertUrl (leaf.PublicUrl);
 419                 }
 420
 421                 IEnumerable<Node> GetLeaves (Node node)
 422                 {
 423                         if (node == null)
 424                                 yield break;
 425
 426                         if (node.IsLeaf)
 427                                 yield return node;
 428                         else {
 429                                 foreach (var child in node.Nodes) {
 430                                         if (!string.IsNullOrEmpty (child.Element) && !child.Element.StartsWith ("root:/"))
 431                                                 yield return child;
 432                                         foreach (var childLeaf in GetLeaves (child))
 433                                                 yield return childLeaf;
 434                                 }
 435                         }
 436                 }
 437
 438                 bool IsEcmaNode (Node node)
 439                 {
 440                         var url = node.PublicUrl;
 441                         return url != null && url.Length > 2 && url[1] == ':';
 442                 }*/
 443         }
 444 }