public void GetFriendlyName_ShouldNotReturnNamespaceForNestedTypes()
{
CSharpCompilation compilation = CreateCompilation
(@"
namespace Cica.Mica
{
public class GenericParent<T>
{
public class GenericChild<TT>
{
}
}
}
");
var visitor = new FindAllTypesVisitor();
visitor.VisitNamespace(compilation.GlobalNamespace);
INamedTypeSymbol
parent = visitor.AllTypeSymbols.Single(m => m.Name == "GenericParent"),
child = visitor.AllTypeSymbols.Single(m => m.Name == "GenericChild");
Assert.That(parent.GetFriendlyName(), Is.EqualTo("Cica.Mica.GenericParent"));
Assert.That(child.GetFriendlyName(), Is.EqualTo("GenericChild"));
}
public void IsSpecial_ShouldReturnTrueForSpecialMethods(string name, bool isSpecial)
{
CSharpCompilation compilation = CreateCompilation
(@"
interface IInterface
{
int Prop1 { get; }
int Prop2 { get; }
}
class MyClass: IInterface
{
public void Foo() {}
int IInterface.Prop1 => 0;
public int Prop2 => 2;
}
");
var visitor = new FindAllTypesVisitor();
visitor.VisitNamespace(compilation.GlobalNamespace);
IMethodSymbol[] methods = visitor
.AllTypeSymbols
.Single(t => t.Name == "MyClass")
.GetMembers()
.OfType <IMethodSymbol>()
.ToArray();
Assert.That(methods.Single(m => m.StrippedName() == name).IsSpecial(), Is.EqualTo(isSpecial));
}
public void GetAccessModifiers_ShouldReturnTheCorrectAccessModifier(string name, int am)
{
AccessModifiers accessModifiers = (AccessModifiers)am;
CSharpCompilation compilation = CreateCompilation
(@"
interface IInterface
{
void Foo();
void Bar();
}
class MyClass: IInterface
{
public void Foo() {}
void IInterface.Bar() {}
public void Baz() {}
internal void FooBar() {}
}
");
var visitor = new FindAllTypesVisitor();
visitor.VisitNamespace(compilation.GlobalNamespace);
IMethodSymbol[] methods = visitor
.AllTypeSymbols
.Single(t => t.Name == "MyClass")
.GetMembers()
.OfType <IMethodSymbol>()
.ToArray();
Assert.That(methods.Single(m => m.StrippedName() == name).GetAccessModifiers(), Is.EqualTo(accessModifiers));
}
public void GetElementType_ShouldReturnTheProperElementType(string src, string element)
{
CSharpCompilation compilation = CreateCompilation(src);
var visitor = new FindAllTypesVisitor();
visitor.VisitNamespace(compilation.GlobalNamespace);
ITypeSymbol ga = visitor.AllTypeSymbols.Single(t => t.Name == "MyList").BaseType.TypeArguments.Single();
Assert.That(ga.GetElementType(recurse: true)?.GetFriendlyName(), Is.EqualTo(element));
}
public void IsGenericParameter_ShouldReturnTrueIfTheTypeIsGenericParameter(string src, bool isGP)
{
CSharpCompilation compilation = CreateCompilation(src);
var visitor = new FindAllTypesVisitor();
visitor.VisitNamespace(compilation.GlobalNamespace);
ITypeSymbol ga = visitor.AllTypeSymbols.Single(t => t.Name == "MyClass").BaseType.TypeArguments.Single();
Assert.That(ga.IsGenericParameter(), Is.EqualTo(isGP));
}
public void ListMethods_ShouldReturnMethodsFromTheWholeHierarchy(string src, string cls)
{
CSharpCompilation compilation = CreateCompilation(src);
var visitor = new FindAllTypesVisitor();
visitor.VisitNamespace(compilation.GlobalNamespace);
INamedTypeSymbol bar = visitor.AllTypeSymbols.Single(t => t.Name == cls);
IMethodSymbol[] methods = bar.ListMethods().ToArray();
Assert.That(methods.Count(m => m.Name == "Foo"), Is.EqualTo(1));
Assert.That(methods.Count(m => m.Name == "Bar"), Is.EqualTo(1));
}
public void GenericParameterAndItsDeclaringGeneric_ShouldBeConsideredEqual()
{
Compilation compilation = CreateCompilation // mondjuk ez kibaszott perverz :D
(@"
interface IGeneric<T>
{
void Foo(IGeneric<T> a, T b);
}
");
var visitor = new FindAllTypesVisitor();
visitor.VisitNamespace(compilation.GlobalNamespace);
ITypeSymbol
a = visitor.AllTypeSymbols.Single(t => t.Name == "IGeneric").ListMethods().Single(m => m.Name == "Foo").Parameters[0].Type,
b = visitor.AllTypeSymbols.Single(t => t.Name == "IGeneric").ListMethods().Single(m => m.Name == "Foo").Parameters[1].Type;
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
Assert.AreEqual(SymbolEqualityComparer.Default.GetHashCode(a), SymbolEqualityComparer.Default.GetHashCode(b));
}
public void PassingByReference_ShouldNotAffectTheParameterType() // TODO: Ne ide
{
CSharpCompilation compilation = CreateCompilation
(@"
public class MyClass
{
void Foo(int a, ref int b) {}
}
");
var visitor = new FindAllTypesVisitor();
visitor.VisitNamespace(compilation.GlobalNamespace);
IMethodSymbol foo = (IMethodSymbol)visitor.AllTypeSymbols.Single(t => t.Name == "MyClass").GetMembers("Foo").Single();
ITypeSymbol
a = foo.Parameters[0].Type,
b = foo.Parameters[0].Type;
Assert.That(SymbolEqualityComparer.Default.Equals(a, b));
}
public void IsNested_ShouldReturnTrueIfTheTypeIsNested()
{
CSharpCompilation compilation = CreateCompilation
(@"
public class MyClass<T>
{
private class Nested {}
}
");
var visitor = new FindAllTypesVisitor();
visitor.VisitNamespace(compilation.GlobalNamespace);
ITypeSymbol ga = visitor.AllTypeSymbols.Single(t => t.Name == "MyClass").TypeArguments.Single();
Assert.IsFalse(ga.IsNested());
ITypeSymbol nested = visitor.AllTypeSymbols.Single(t => t.Name == "Nested");
Assert.That(nested.IsNested());
}
public void EqualsTo_ShouldCompare(string src, bool equals)
{
Assembly asm = Compile(src, customConfig: comp => comp.WithOptions(((CSharpCompilationOptions)comp.Options).WithAllowUnsafe(true)));
ITypeInfo
a1 = MetadataTypeInfo.CreateFrom(asm.GetTypes().Single(t => t.Name.Contains("ClassA")).ListMethods().Single(m => m.Name == "Foo").GetParameters().Single().ParameterType),
b1 = MetadataTypeInfo.CreateFrom(asm.GetTypes().Single(t => t.Name.Contains("ClassB")).ListMethods().Single(m => m.Name == "Foo").GetParameters().Single().ParameterType);
CSharpCompilation compilation = CreateCompilation(src);
var visitor = new FindAllTypesVisitor();
visitor.VisitNamespace(compilation.GlobalNamespace);
ITypeInfo
a2 = SymbolTypeInfo.CreateFrom(visitor.AllTypeSymbols.Single(t => t.Name == "ClassA").ListMethods().Single(m => m.Name == "Foo").Parameters.Single().Type, compilation),
b2 = SymbolTypeInfo.CreateFrom(visitor.AllTypeSymbols.Single(t => t.Name == "ClassB").ListMethods().Single(m => m.Name == "Foo").Parameters.Single().Type, compilation);
Assert.That(a1.EqualsTo(b1), Is.EqualTo(equals));
Assert.That(a2.EqualsTo(b2), Is.EqualTo(equals));
Assert.That(a1.EqualsTo(b2), Is.EqualTo(equals));
Assert.That(a2.EqualsTo(b1), Is.EqualTo(equals));
}
public void SignatureEquals_ShouldReturnTrueOnSignatureEquality(string src, bool equals)
{
Assembly asm = Compile(src);
IMethodInfo
a1 = MetadataMethodInfo.CreateFrom(asm.GetTypes().Single(t => t.Name.Contains("ClassA")).ListMethods().Single(m => m.Name == "Foo")),
b1 = MetadataMethodInfo.CreateFrom(asm.GetTypes().Single(t => t.Name.Contains("ClassB")).ListMethods().Single(m => m.Name == "Foo"));
CSharpCompilation compilation = CreateCompilation(src);
var visitor = new FindAllTypesVisitor();
visitor.VisitNamespace(compilation.GlobalNamespace);
IMethodInfo
a2 = SymbolMethodInfo.CreateFrom(visitor.AllTypeSymbols.Single(t => t.Name == "ClassA").ListMethods().Single(m => m.Name == "Foo"), compilation),
b2 = SymbolMethodInfo.CreateFrom(visitor.AllTypeSymbols.Single(t => t.Name == "ClassB").ListMethods().Single(m => m.Name == "Foo"), compilation);
Assert.That(a1.SignatureEquals(b1), Is.EqualTo(equals));
Assert.That(a2.SignatureEquals(b2), Is.EqualTo(equals));
Assert.That(a1.SignatureEquals(b2), Is.EqualTo(equals));
Assert.That(a2.SignatureEquals(b1), Is.EqualTo(equals));
}
