840 lines
23 KiB
C#
840 lines
23 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Collections.Generic;
|
|
|
|
using NUnit.Framework;
|
|
|
|
using Monodoc;
|
|
using Monodoc.Ecma;
|
|
|
|
namespace MonoTests.Monodoc.Ecma
|
|
{
|
|
[TestFixture]
|
|
public class EcmaUrlTests
|
|
{
|
|
EcmaUrlParser parser;
|
|
|
|
[SetUp]
|
|
public void Setup ()
|
|
{
|
|
parser = new EcmaUrlParser ();
|
|
}
|
|
|
|
void AssertValidUrl (string url)
|
|
{
|
|
try {
|
|
parser.IsValid (url);
|
|
} catch {
|
|
Assert.Fail (string.Format ("URL '{0}' deemed not valid", url));
|
|
}
|
|
}
|
|
|
|
void AssertInvalidUrl (string url)
|
|
{
|
|
try {
|
|
parser.IsValid (url);
|
|
} catch {
|
|
return;
|
|
}
|
|
Assert.Fail (string.Format ("URL '{0}' deemed valid", url));
|
|
}
|
|
|
|
void AssertUrlDesc (EcmaDesc expected, string url)
|
|
{
|
|
EcmaDesc actual = null;
|
|
try {
|
|
actual = parser.Parse (url);
|
|
} catch (Exception e) {
|
|
Assert.Fail (string.Format ("URL '{0}' deemed not valid: {1}{2}", url, Environment.NewLine, e.ToString ()));
|
|
}
|
|
|
|
Assert.AreEqual (expected, actual, "Converted URL differs");
|
|
}
|
|
|
|
void AssertEcmaString (string expected, EcmaDesc actual)
|
|
{
|
|
string actualString = actual.ToEcmaCref ();
|
|
Assert.AreEqual (expected, actualString);
|
|
}
|
|
|
|
IEnumerable<EcmaDesc> GenericTypeArgumentsList (params string[] parameters)
|
|
{
|
|
foreach (var p in parameters)
|
|
yield return new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = p,
|
|
Namespace = string.Empty
|
|
};
|
|
}
|
|
|
|
[Test]
|
|
public void CommonMethodUrlIsValidTest ()
|
|
{
|
|
AssertValidUrl ("M:System.String.FooBar()");
|
|
AssertValidUrl ("M:System.String.FooBar(System.String, Int32)");
|
|
AssertValidUrl ("M:System.Foo.Int32<System.String+FooBar<System.Blop<T, U`2>>>.Foo()");
|
|
AssertValidUrl ("M:System.Foo.Int32<System.String+FooBar<System.Blop<T, U`2>>>.Foo(Bleh,Bar)");
|
|
AssertValidUrl ("M:System.Foo.Int32<System.String+FooBar<System.Blop<T, U`2>>>.Foo(Bleh<V>,Bar)");
|
|
AssertValidUrl ("M:Gendarme.Framework.Helpers.Log.WriteLine(string,string,object[])");
|
|
AssertValidUrl ("M:Mono.Security.X509.Extensions.SubjectKeyIdentifierExtension.Decode");
|
|
AssertValidUrl ("M:Mono.Security.PKCS7.IssuerAndSerialNumber");
|
|
}
|
|
|
|
[Test]
|
|
public void CommonTypeUrlIsValidTest ()
|
|
{
|
|
AssertValidUrl ("T:Int32");
|
|
AssertValidUrl ("T:System.Foo.Int32");
|
|
AssertValidUrl ("T:System.Foo.Int32<System.String+FooBar`1>");
|
|
AssertValidUrl ("T:System.Foo.Int32<System.String+FooBar<System.Blop<T, U>>>");
|
|
AssertValidUrl ("T:System.Foo.Int32<T>");
|
|
AssertValidUrl ("T:System.Foo.Int32<T,U>");
|
|
AssertValidUrl ("T:System.Foo.Int32<System.String+FooBar<System.Blop<T, U>>>");
|
|
AssertValidUrl ("T:System.Foo.Int32<System.String+FooBar<System.Blop<T, U`2>>>");
|
|
}
|
|
|
|
[Test]
|
|
public void CommonTypeUrlNotValidTest ()
|
|
{
|
|
AssertInvalidUrl ("TInt32");
|
|
AssertInvalidUrl ("K:Int32");
|
|
AssertInvalidUrl ("T:System..Foo.Int32");
|
|
AssertInvalidUrl ("T:System.Foo.Int32<System.String+FooBar`1");
|
|
AssertInvalidUrl ("T:System.Foo.Int32<System.String+FooBarSystem.Blop<T, U>>>");
|
|
AssertInvalidUrl ("T:System.Foo.Int32<T,>");
|
|
AssertInvalidUrl ("T:System.Foo.Int32<+FooBar<System.Blop<T, U>>>");
|
|
}
|
|
|
|
[Test]
|
|
public void NamespaceValidTest ()
|
|
{
|
|
AssertValidUrl ("N:Foo.Bar");
|
|
AssertValidUrl ("N:Foo");
|
|
AssertValidUrl ("N:Foo.Bar.Baz");
|
|
AssertValidUrl ("N:A.B.C");
|
|
|
|
var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Namespace,
|
|
Namespace = "Foo.Bar.Blop" };
|
|
AssertUrlDesc (ast, "N:Foo.Bar.Blop");
|
|
}
|
|
|
|
[Test]
|
|
public void ConstructorValidTest ()
|
|
{
|
|
AssertValidUrl ("C:Gendarme.Rules.Concurrency.DecorateThreadsRule.DecorateThreadsRule");
|
|
AssertValidUrl ("C:Gendarme.Rules.Concurrency.DecorateThreadsRule.DecorateThreadsRule()");
|
|
AssertValidUrl ("C:Gendarme.Rules.Concurrency.DecorateThreadsRule.DecorateThreadsRule(System.String)");
|
|
AssertValidUrl ("C:Gendarme.Framework.Helpers.MethodSignature.MethodSignature(string,string,string[],System.Func<Mono.Cecil.MethodReference,System.Boolean>)");
|
|
AssertValidUrl ("C:System.Collections.Generic.Dictionary<TKey,TValue>+KeyCollection.KeyCollection(System.Collections.Generic.Dictionary<TKey,TValue>)");
|
|
AssertValidUrl ("C:Microsoft.Build.Utilities.TaskItem(System.String,System.Collections.IDictionary)");
|
|
}
|
|
|
|
[Test]
|
|
public void SlashExpressionValidTest ()
|
|
{
|
|
AssertValidUrl ("T:Foo.Bar.Type/*");
|
|
AssertValidUrl ("T:Foo.Bar.Type/M");
|
|
AssertValidUrl ("T:Gendarme.Framework.Bitmask<T>/M/Equals");
|
|
AssertValidUrl ("T:Gendarme.Framework.Helpers.Log/M/WriteLine<T>");
|
|
AssertValidUrl ("T:System.Windows.Forms.AxHost/M/System.ComponentModel.ICustomTypeDescriptor.GetEvents");
|
|
}
|
|
|
|
[Test]
|
|
public void MethodWithArgModValidTest ()
|
|
{
|
|
AssertValidUrl ("M:Foo.Bar.FooBar(int, System.Drawing.Imaging&)");
|
|
AssertValidUrl ("M:Foo.Bar.FooBar(int@, System.Drawing.Imaging)");
|
|
AssertValidUrl ("M:Foo.Bar.FooBar(int, System.Drawing.Imaging*)");
|
|
AssertValidUrl ("M:Foo.Bar.FooBar(int*, System.Drawing.Imaging&)");
|
|
AssertValidUrl ("M:Atk.NoOpObject.GetRunAttributes(int,int&,int&)");
|
|
}
|
|
|
|
[Test]
|
|
public void MethodWithJaggedArrayArgsValidTest ()
|
|
{
|
|
AssertValidUrl ("M:System.Reflection.Emit.SignatureHelper.GetPropertySigHelper(System.Reflection.Module,System.Reflection.CallingConventions,Type,Type[],Type[],Type[],Type[][],Type[][])");
|
|
}
|
|
|
|
[Test]
|
|
public void MethodWithInnerTypeValidTest ()
|
|
{
|
|
AssertValidUrl ("M:System.TimeZoneInfo+AdjustmentRule.CreateAdjustmentRule");
|
|
}
|
|
|
|
[Test]
|
|
public void FieldValidTest ()
|
|
{
|
|
AssertValidUrl ("F:Mono.Terminal.Curses.KeyF10");
|
|
AssertValidUrl ("F:Novell.Directory.Ldap.Utilclass.ExceptionMessages.NOT_IMPLEMENTED");
|
|
AssertValidUrl ("F:Novell.Directory.Ldap.LdapException.NOT_ALLOWED_ON_NONLEAF");
|
|
}
|
|
|
|
[Test]
|
|
public void PropertyValidTest ()
|
|
{
|
|
AssertValidUrl ("P:System.Foo.Bar");
|
|
AssertValidUrl ("P:System.ArraySegment<T>.Array");
|
|
}
|
|
|
|
[Test]
|
|
public void IndexPropertyValidTest ()
|
|
{
|
|
AssertValidUrl ("P:System.ComponentModel.PropertyDescriptorCollection.Item(int)");
|
|
AssertValidUrl ("P:System.ComponentModel.AttributeCollection.Item(Type)");
|
|
AssertValidUrl ("P:System.Web.SessionState.HttpSessionStateContainer$System.Web.SessionState.IHttpSessionState.Item(System.Int32)");
|
|
AssertValidUrl ("P:System.Collections.Specialized.BitVector32.Item(System.Collections.Specialized.BitVector32+Section)");
|
|
}
|
|
|
|
[Test]
|
|
public void ExplicitMethodImplValidTest ()
|
|
{
|
|
AssertValidUrl ("M:Microsoft.Win32.RegistryKey$System.IDisposable.Dispose");
|
|
}
|
|
|
|
[Test]
|
|
public void AspNetSafeUrlValidTest ()
|
|
{
|
|
AssertValidUrl ("M:MonoTouch.UIKit.UICollectionViewLayoutAttributes.CreateForCell{T}");
|
|
}
|
|
|
|
[Test]
|
|
public void GenericTypeArgsIsNumericTest ()
|
|
{
|
|
var desc = parser.Parse ("T:System.Collections.Generic.Dictionary`2");
|
|
Assert.IsTrue (desc.GenericTypeArgumentsIsNumeric);
|
|
Assert.AreEqual (2, desc.GenericTypeArguments.Count);
|
|
desc = parser.Parse ("T:System.Collections.Generic.Dictionary<TKey,TValue>");
|
|
Assert.IsFalse (desc.GenericTypeArgumentsIsNumeric);
|
|
}
|
|
|
|
[Test]
|
|
public void GenericTypeArgsNumericToStringTest ()
|
|
{
|
|
string stringCref = "T:System.Collections.Generic.Dictionary`2";
|
|
var desc = parser.Parse (stringCref);
|
|
Assert.IsTrue (desc.GenericTypeArgumentsIsNumeric);
|
|
Assert.AreEqual (2, desc.GenericTypeArguments.Count);
|
|
string generatedEcmaCref = desc.ToEcmaCref ();
|
|
Assert.AreEqual (stringCref, generatedEcmaCref);
|
|
}
|
|
|
|
[Test]
|
|
public void MetaEtcNodeTest ()
|
|
{
|
|
var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "Foo.Bar",
|
|
TypeName = "Type",
|
|
Etc = '*' };
|
|
AssertUrlDesc (ast, "T:Foo.Bar.Type/*");
|
|
}
|
|
|
|
[Test]
|
|
public void MetaEtcWithInnerTypeTest ()
|
|
{
|
|
var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "Novell.Directory.Ldap",
|
|
TypeName = "Connection",
|
|
NestedType = new EcmaDesc { DescKind = EcmaDesc.Kind.Type, TypeName = "ReaderThread" },
|
|
Etc = '*' };
|
|
AssertUrlDesc (ast, "T:Novell.Directory.Ldap.Connection+ReaderThread/*");
|
|
}
|
|
|
|
[Test]
|
|
public void SimpleTypeUrlParseTest ()
|
|
{
|
|
var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "String",
|
|
Namespace = "System" };
|
|
AssertUrlDesc (ast, "T:System.String");
|
|
}
|
|
|
|
[Test]
|
|
public void TypeWithOneGenericUrlParseTest ()
|
|
{
|
|
var generics = new[] {
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = string.Empty,
|
|
TypeName = "T"
|
|
}
|
|
};
|
|
var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "String",
|
|
Namespace = "System",
|
|
GenericTypeArguments = generics,
|
|
};
|
|
|
|
AssertUrlDesc (ast, "T:System.String<T>");
|
|
}
|
|
|
|
[Test]
|
|
public void TypeWithOneGenericUrlParseTestUsingAspNetStyleUrl ()
|
|
{
|
|
var generics = new[] {
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = string.Empty,
|
|
TypeName = "T"
|
|
}
|
|
};
|
|
var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "String",
|
|
Namespace = "System",
|
|
GenericTypeArguments = generics,
|
|
};
|
|
|
|
AssertUrlDesc (ast, "T:System.String{T}");
|
|
}
|
|
|
|
[Test]
|
|
public void TypeWithNestedGenericUrlParseTest ()
|
|
{
|
|
var generics = new[] {
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "T",
|
|
Namespace = string.Empty
|
|
},
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System.Collections.Generic",
|
|
TypeName = "List",
|
|
GenericTypeArguments = new[] {
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "V",
|
|
Namespace = string.Empty
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "String",
|
|
Namespace = "System",
|
|
GenericTypeArguments = generics,
|
|
};
|
|
|
|
AssertUrlDesc (ast, "T:System.String<T, System.Collections.Generic.List<V>>");
|
|
}
|
|
|
|
[Test]
|
|
public void SimpleMethodUrlParseTest ()
|
|
{
|
|
var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Method,
|
|
TypeName = "String",
|
|
Namespace = "System",
|
|
MemberName = "FooBar"
|
|
};
|
|
AssertUrlDesc (ast, "M:System.String.FooBar()");
|
|
}
|
|
|
|
[Test]
|
|
public void MethodWithArgsUrlParseTest ()
|
|
{
|
|
var args = new[] {
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System",
|
|
TypeName = "String"
|
|
},
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "Int32",
|
|
Namespace = string.Empty
|
|
}
|
|
};
|
|
var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Method,
|
|
TypeName = "String",
|
|
Namespace = "System",
|
|
MemberName = "FooBar",
|
|
MemberArguments = args
|
|
};
|
|
AssertUrlDesc (ast, "M:System.String.FooBar(System.String, Int32)");
|
|
}
|
|
|
|
[Test]
|
|
public void MethodWithArgsAndGenericsUrlParseTest ()
|
|
{
|
|
var args = new[] {
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System",
|
|
TypeName = "String"
|
|
},
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System.Collections.Generic",
|
|
TypeName = "Dictionary",
|
|
GenericTypeArguments = new[] {
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "K",
|
|
Namespace = string.Empty
|
|
},
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "V",
|
|
Namespace = string.Empty
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
var generics = new[] {
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "Action",
|
|
Namespace = string.Empty,
|
|
GenericTypeArguments = new[] {
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System",
|
|
TypeName = "Single",
|
|
},
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "int",
|
|
Namespace = string.Empty
|
|
},
|
|
}
|
|
}
|
|
};
|
|
|
|
var ast = new EcmaDesc () { DescKind = EcmaDesc.Kind.Method,
|
|
TypeName = "String",
|
|
Namespace = "System",
|
|
MemberName = "FooBar",
|
|
MemberArguments = args,
|
|
GenericMemberArguments = generics
|
|
};
|
|
AssertUrlDesc (ast, "M:System.String.FooBar<Action<System.Single, int>>(System.String, System.Collections.Generic.Dictionary<K, V>)");
|
|
}
|
|
|
|
[Test]
|
|
public void ExplicitMethodImplementationParseTest ()
|
|
{
|
|
var inner = new EcmaDesc {
|
|
MemberName = "Dispose",
|
|
TypeName = "IDisposable",
|
|
Namespace = "System"
|
|
};
|
|
var ast = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Method,
|
|
TypeName = "RegistryKey",
|
|
Namespace = "Microsoft.Win32",
|
|
ExplicitImplMember = inner
|
|
};
|
|
AssertUrlDesc (ast, "M:Microsoft.Win32.RegistryKey$System.IDisposable.Dispose");
|
|
}
|
|
|
|
[Test]
|
|
public void SimpleMethodWithNumberInType ()
|
|
{
|
|
var ast = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Method,
|
|
TypeName = "ASN1",
|
|
Namespace = "Mono.Security",
|
|
MemberName = "Add"
|
|
};
|
|
AssertUrlDesc (ast, "M:Mono.Security.ASN1.Add");
|
|
}
|
|
|
|
[Test]
|
|
public void JaggedArrayWithDimensions ()
|
|
{
|
|
var ast = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "Int32",
|
|
Namespace = "System",
|
|
ArrayDimensions = new int[] { 3, 1, 1 }
|
|
};
|
|
AssertUrlDesc (ast, "T:System.Int32[,,][][]");
|
|
}
|
|
|
|
[Test]
|
|
public void ExplicitIndexerImplementation ()
|
|
{
|
|
var explicitImpl = new EcmaDesc {
|
|
Namespace = "System.Web.SessionState",
|
|
TypeName = "IHttpSessionState",
|
|
MemberName = "Item",
|
|
MemberArguments = new [] { new EcmaDesc { DescKind = EcmaDesc.Kind.Type, Namespace = "System", TypeName = "Int32" } },
|
|
};
|
|
var ast = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Property,
|
|
TypeName = "HttpSessionStateContainer",
|
|
Namespace = "System.Web.SessionState",
|
|
ExplicitImplMember = explicitImpl,
|
|
};
|
|
AssertUrlDesc (ast, "P:System.Web.SessionState.HttpSessionStateContainer$System.Web.SessionState.IHttpSessionState.Item(System.Int32)");
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_Namespace ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Namespace,
|
|
Namespace = "System.IO",
|
|
};
|
|
|
|
AssertEcmaString ("N:System.IO", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_SimpleType ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System.IO",
|
|
TypeName = "Path",
|
|
};
|
|
|
|
AssertEcmaString ("T:System.IO.Path", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_NestedType ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System.IO",
|
|
TypeName = "Path",
|
|
NestedType = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "TheNestedType",
|
|
},
|
|
};
|
|
|
|
AssertEcmaString ("T:System.IO.Path+TheNestedType", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_NestedType_FourDeep ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "Mono",
|
|
TypeName = "DocTest",
|
|
NestedType = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "NestedClass",
|
|
NestedType = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "Double",
|
|
NestedType = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "Triple",
|
|
NestedType = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "Quadruple",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
};
|
|
|
|
string targetUrl = "T:Mono.DocTest+NestedClass+Double+Triple+Quadruple";
|
|
AssertEcmaString (targetUrl, actual);
|
|
AssertUrlDesc (actual, targetUrl);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_NestedType_Field ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Field,
|
|
Namespace = "System.IO",
|
|
TypeName = "Path",
|
|
NestedType = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "TheNestedType",
|
|
},
|
|
MemberName = "NestedField"
|
|
};
|
|
|
|
AssertEcmaString ("F:System.IO.Path+TheNestedType.NestedField", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_SimpleType_WithGenerics ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System.IO",
|
|
TypeName = "Path",
|
|
GenericTypeArguments = GenericTypeArgumentsList ("K").ToArray ()
|
|
};
|
|
|
|
AssertEcmaString ("T:System.IO.Path<K>", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_Nestedype_WithGenerics ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System.IO",
|
|
TypeName = "Path",
|
|
NestedType = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "TheNestedType",
|
|
},
|
|
GenericTypeArguments = GenericTypeArgumentsList ("K").ToArray ()
|
|
};
|
|
|
|
AssertEcmaString ("T:System.IO.Path<K>+TheNestedType", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_Nestedype_WithGenericsOnBoth ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System.IO",
|
|
TypeName = "Path",
|
|
NestedType = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "TheNestedType",
|
|
GenericTypeArguments = GenericTypeArgumentsList ("T", "V").ToArray (),
|
|
},
|
|
GenericTypeArguments = GenericTypeArgumentsList ("K").ToArray ()
|
|
};
|
|
|
|
AssertEcmaString ("T:System.IO.Path<K>+TheNestedType<T,V>", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_Nestedype_Property_WithGenericsOnBoth ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Property,
|
|
Namespace = "System.IO",
|
|
TypeName = "Path",
|
|
NestedType = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
TypeName = "TheNestedType",
|
|
GenericTypeArguments = GenericTypeArgumentsList ("T", "V").ToArray (),
|
|
},
|
|
GenericTypeArguments = GenericTypeArgumentsList ("K").ToArray (),
|
|
MemberName = "TheProperty"
|
|
};
|
|
|
|
AssertEcmaString ("P:System.IO.Path<K>+TheNestedType<T,V>.TheProperty", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_Field ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Field,
|
|
Namespace = "System.IO",
|
|
TypeName = "Path",
|
|
MemberName = "TheField"
|
|
};
|
|
|
|
AssertEcmaString ("F:System.IO.Path.TheField", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_ExplicitlyImplemented_Field ()
|
|
{
|
|
var explicitImpl = new EcmaDesc {
|
|
Namespace = "System.Web.SessionState",
|
|
TypeName = "IHttpSessionState",
|
|
MemberName = "Item",
|
|
};
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Field,
|
|
TypeName = "HttpSessionStateContainer",
|
|
Namespace = "System.Web.SessionState",
|
|
ExplicitImplMember = explicitImpl,
|
|
};
|
|
AssertEcmaString ("F:System.Web.SessionState.HttpSessionStateContainer$System.Web.SessionState.IHttpSessionState.Item", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_Property ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Property,
|
|
Namespace = "System.IO",
|
|
TypeName = "Path",
|
|
MemberName = "TheProperty",
|
|
};
|
|
|
|
AssertEcmaString ("P:System.IO.Path.TheProperty", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_ExplicitlyImplemented_Property ()
|
|
{
|
|
var explicitImpl = new EcmaDesc {
|
|
Namespace = "System.Web.SessionState",
|
|
TypeName = "IHttpSessionState",
|
|
MemberName = "Item",
|
|
};
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Property,
|
|
TypeName = "HttpSessionStateContainer",
|
|
Namespace = "System.Web.SessionState",
|
|
ExplicitImplMember = explicitImpl,
|
|
};
|
|
AssertEcmaString ("P:System.Web.SessionState.HttpSessionStateContainer$System.Web.SessionState.IHttpSessionState.Item", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_ExplicitlyImplemented_Method ()
|
|
{
|
|
var explicitImpl = new EcmaDesc {
|
|
Namespace = "System.Web.SessionState",
|
|
TypeName = "IHttpSessionState",
|
|
MemberName = "Item",
|
|
MemberArguments = new [] {
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System",
|
|
TypeName = "Int32",
|
|
},
|
|
},
|
|
};
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Method,
|
|
TypeName = "HttpSessionStateContainer",
|
|
Namespace = "System.Web.SessionState",
|
|
ExplicitImplMember = explicitImpl,
|
|
};
|
|
AssertEcmaString ("M:System.Web.SessionState.HttpSessionStateContainer$System.Web.SessionState.IHttpSessionState.Item(System.Int32)", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_Event ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Event,
|
|
Namespace = "System.IO",
|
|
TypeName = "Path",
|
|
MemberName = "TheEvent",
|
|
};
|
|
|
|
AssertEcmaString ("E:System.IO.Path.TheEvent", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_Operator ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Operator,
|
|
Namespace = "System",
|
|
TypeName = "Int32",
|
|
MemberName = "Addition",
|
|
};
|
|
|
|
AssertEcmaString ("O:System.Int32.Addition", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_Operator_Conversion ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Operator,
|
|
Namespace = "System",
|
|
TypeName = "Int32",
|
|
MemberName = "ExplicitConversion",
|
|
MemberArguments = new [] {
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System",
|
|
TypeName = "Double",
|
|
},
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System",
|
|
TypeName = "Int32",
|
|
}
|
|
},
|
|
};
|
|
|
|
AssertEcmaString ("O:System.Int32.ExplicitConversion(System.Double,System.Int32)", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_Method ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Method,
|
|
Namespace = "System",
|
|
TypeName = "Int32",
|
|
MemberName = "Add"
|
|
};
|
|
|
|
AssertEcmaString ("M:System.Int32.Add", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_Method_Parameters ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Method,
|
|
Namespace = "System",
|
|
TypeName = "Int32",
|
|
MemberName = "Add",
|
|
MemberArguments = new [] {
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System",
|
|
TypeName = "Double",
|
|
},
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "System",
|
|
TypeName = "Int32",
|
|
},
|
|
},
|
|
};
|
|
|
|
AssertEcmaString ("M:System.Int32.Add(System.Double,System.Int32)", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_Method_Generics ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Method,
|
|
Namespace = "System",
|
|
TypeName = "Int32",
|
|
MemberName = "Add",
|
|
GenericMemberArguments = GenericTypeArgumentsList ("T", "K").ToArray (),
|
|
};
|
|
|
|
AssertEcmaString ("M:System.Int32.Add<T,K>", actual);
|
|
}
|
|
|
|
[Test]
|
|
public void ToEcmaCref_Method_Generics_PlusParameters ()
|
|
{
|
|
var actual = new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Method,
|
|
Namespace = "System",
|
|
TypeName = "Int32",
|
|
MemberName = "Add",
|
|
GenericMemberArguments = GenericTypeArgumentsList ("T", "K").ToArray (),
|
|
MemberArguments = new [] {
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "",
|
|
TypeName = "T",
|
|
},
|
|
new EcmaDesc {
|
|
DescKind = EcmaDesc.Kind.Type,
|
|
Namespace = "",
|
|
TypeName = "K",
|
|
},
|
|
},
|
|
};
|
|
|
|
AssertEcmaString ("M:System.Int32.Add<T,K>(T,K)", actual);
|
|
}
|
|
}
|
|
}
|