public void CanReturnMultipleAttributes()
{
Data.MemberData data = GetMember("[Test][Other]class Test { }");
AttributeData[] attributes = data.GetAttributes().ToArray();
Assert.True(
attributes.Length == 2 &&
attributes.Any(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, Compilation.CurrentCompilation.GetTypeByMetadataName("TestAttribute") !)) &&
attributes.Any(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, Compilation.CurrentCompilation.GetTypeByMetadataName("OtherAttribute") !))
);
}
/// <summary>
/// Create a new query object around a collected .NET member data.
/// </summary>
/// <param name="memberData">The collected .NET member data.</param>
public MemberData(Data.MemberData memberData)
{
if (memberData.Constructors != null)
{
Constructors = new List <IReadOnlyList <string> >(memberData.Constructors);
}
if (memberData.Fields != null)
{
Fields = CreateFieldTable(memberData.Fields);
}
if (memberData.Properties != null)
{
Properties = CreatePropertyTable(memberData.Properties);
}
if (memberData.Methods != null)
{
Methods = CreateMethodTable(memberData.Methods);
}
if (memberData.Events != null)
{
Events = CreateEventTable(memberData.Events);
}
if (memberData.NestedTypes != null)
{
NestedTypes = CreateNestedTypeTable(memberData.NestedTypes);
}
if (memberData.Indexers != null)
{
Indexers = CreateIndexerList(memberData.Indexers);
}
}
/// <summary>
/// Create a new query object around a collected .NET member data.
/// </summary>
/// <param name="memberData">The collected .NET member data.</param>
public MemberData(Data.MemberData memberData)
{
if (memberData.Constructors != null)
{
Constructors = memberData.Constructors;
}
if (memberData.Fields != null)
{
_fields = new Lazy <IReadOnlyDictionary <string, FieldData> >(() => CreateFieldTable(memberData.Fields));
}
if (memberData.Properties != null)
{
_properties = new Lazy <IReadOnlyDictionary <string, PropertyData> >(() => CreatePropertyTable(memberData.Properties));
}
if (memberData.Methods != null)
{
_methods = new Lazy <IReadOnlyDictionary <string, MethodData> >(() => CreateMethodTable(memberData.Methods));
}
if (memberData.Events != null)
{
_events = new Lazy <IReadOnlyDictionary <string, EventData> >(() => CreateEventTable(memberData.Events));
}
if (memberData.NestedTypes != null)
{
_nestedtypes = new Lazy <IReadOnlyDictionary <string, TypeData> >(() => CreateNestedTypeTable(memberData.NestedTypes));
}
if (memberData.Indexers != null)
{
_indexers = new Lazy <IReadOnlyList <IndexerData> >(() => CreateIndexerList(memberData.Indexers));
}
}
public void ReturnsTypesInParentFirstOrder()
{
Data.MemberData data = GetMember("class Test { class Parent { class Child { } } }", 2);
ITypeData[] containingTypes = data.GetContainingTypes().ToArray();
Assert.True(containingTypes.Length == 2 && containingTypes[0].Symbol.Name == "Test" && containingTypes[1].Symbol.Name == "Parent");
}
public void ReturnsEmpty_When_IsNotNestedType()
{
Data.MemberData data = GetMember("class Test { }");
ITypeData[] containingTypes = data.GetContainingTypes().ToArray();
Assert.True(containingTypes.Length == 0);
}
public void CanReturnSingleType()
{
Data.MemberData data = GetMember("class Parent { class Child { } }", 1);
ITypeData[] containingTypes = data.GetContainingTypes().ToArray();
Assert.True(containingTypes.Length == 1 && containingTypes[0].Symbol.Name == "Parent");
}
public void CanReturnMultipleTypes()
{
Data.MemberData data = GetMember("class Test { class Parent { class Child { } } }", 2);
ITypeData[] containingTypes = data.GetContainingTypes().ToArray();
Assert.True(containingTypes.Length == 2 && containingTypes.Any(t => t.Symbol.Name == "Parent") && containingTypes.Any(t => t.Symbol.Name == "Test"));
}
public void ReturnsNamespacesInParentFirstOrder()
{
Data.MemberData data = GetMember("namespace N1.N2 { class Parent { } }", 1);
INamespaceSymbol[] containingNamespaces = data.GetContainingNamespaces().ToArray();
Assert.True(containingNamespaces.Length == 2 && containingNamespaces[0].Name == "N1" && containingNamespaces[1].Name == "N2");
}
public void ReturnsEmpty_When_IsNotInNamespace()
{
Data.MemberData data = GetMember("class Test { }");
INamespaceSymbol[] containingNamespaces = data.GetContainingNamespaces().ToArray();
Assert.True(containingNamespaces.Length == 0);
}
public void CanReturnSingleNamespace()
{
Data.MemberData data = GetMember("namespace N1 { class Parent { } }", 1);
INamespaceSymbol[] containingNamespaces = data.GetContainingNamespaces().ToArray();
Assert.True(containingNamespaces.Length == 1 && containingNamespaces[0].Name == "N1");
}
public void CanReturnMultipleNamespaces()
{
Data.MemberData data = GetMember("namespace N1.N2 { class Parent { } }", 1);
INamespaceSymbol[] containingNamespaces = data.GetContainingNamespaces().ToArray();
Assert.True(containingNamespaces.Length == 2 && containingNamespaces.Any(t => t.Name == "N1") && containingNamespaces.Any(t => t.Name == "N2"));
}
public void ReturnsEmpty_When_HasNoAttributes()
{
Data.MemberData data = GetMember("class Test { }");
Assert.Empty(data.GetAttributes());
}
public void CanReturnSingleAttribute()
{
Data.MemberData data = GetMember("[Test]class Test { }");
AttributeData[] attributes = data.GetAttributes().ToArray();
Assert.True(attributes.Length == 1 && SymbolEqualityComparer.Default.Equals(attributes[0].AttributeClass, Compilation.CurrentCompilation.GetTypeByMetadataName("TestAttribute") !));
}
