public void Test3()
{
var assembly = MetadataTestHelpers.GetSymbolForReference(Net40.mscorlib);
var module0 = assembly.Modules[0];
var globalNS = module0.GlobalNamespace;
Assert.Same(globalNS.ContainingAssembly, assembly);
Assert.Same(globalNS.ContainingSymbol, module0);
Assert.True(globalNS.IsGlobalNamespace);
var extent = globalNS.Extent;
Assert.Equal(NamespaceKind.Module, extent.Kind);
Assert.Same(extent.Module, module0);
Assert.Equal(1, globalNS.ConstituentNamespaces.Length);
Assert.Same(globalNS, globalNS.ConstituentNamespaces[0]);
var systemNS = (NamespaceSymbol)globalNS.GetMembers("System").Single();
Assert.Same(systemNS.ContainingAssembly, assembly);
Assert.Same(systemNS.ContainingSymbol, globalNS);
Assert.False(systemNS.IsGlobalNamespace);
extent = systemNS.Extent;
Assert.Equal(NamespaceKind.Module, extent.Kind);
Assert.Same(extent.Module, module0);
Assert.Equal(1, systemNS.ConstituentNamespaces.Length);
Assert.Same(systemNS, systemNS.ConstituentNamespaces[0]);
var collectionsNS = (NamespaceSymbol)systemNS.GetMembers("Collections").Single();
Assert.Same(collectionsNS.ContainingAssembly, assembly);
Assert.Same(collectionsNS.ContainingSymbol, systemNS);
Assert.False(collectionsNS.IsGlobalNamespace);
extent = collectionsNS.Extent;
Assert.Equal(NamespaceKind.Module, extent.Kind);
Assert.Same(extent.Module, module0);
Assert.Equal(1, collectionsNS.ConstituentNamespaces.Length);
Assert.Same(collectionsNS, collectionsNS.ConstituentNamespaces[0]);
}
public void Test1()
{
var assembly = MetadataTestHelpers.GetSymbolForReference(Net40.mscorlib);
TestBaseTypeResolutionHelper1(assembly);
var assemblies = MetadataTestHelpers.GetSymbolsForReferences(
mrefs: new[]
{
TestReferences.SymbolsTests.MDTestLib1,
TestReferences.SymbolsTests.MDTestLib2,
Net40.mscorlib
}
);
TestBaseTypeResolutionHelper2(assemblies);
assemblies = MetadataTestHelpers.GetSymbolsForReferences(
mrefs: new[]
{
TestReferences.SymbolsTests.MDTestLib1,
TestReferences.SymbolsTests.MDTestLib2
}
);
// TestBaseTypeResolutionHelper3(assemblies); // TODO(alekseyt): this test is not valid. See email of 7/23/2010 for explanation.
assemblies = MetadataTestHelpers.GetSymbolsForReferences(
mrefs: new[]
{
TestReferences.SymbolsTests.MultiModule.Assembly,
TestReferences.SymbolsTests.MultiModule.Consumer
}
);
TestBaseTypeResolutionHelper4(assemblies);
}
public void TestExplicitImplementationSimple()
{
var assembly = MetadataTestHelpers.GetSymbolForReference(
TestReferences.SymbolsTests.ExplicitInterfaceImplementation.Properties.CSharp);
var globalNamespace = assembly.GlobalNamespace;
var @interface = (NamedTypeSymbol)globalNamespace.GetTypeMembers("Interface").Single();
Assert.Equal(TypeKind.Interface, @interface.TypeKind);
var interfaceProperty = (PropertySymbol)@interface.GetMembers("Property").Single();
var @class = (NamedTypeSymbol)globalNamespace.GetTypeMembers("Class").Single();
Assert.Equal(TypeKind.Class, @class.TypeKind);
Assert.True(@class.Interfaces.Contains(@interface));
var classProperty = (PropertySymbol)@class.GetMembers("Interface.Property").Single();
var explicitImpl = classProperty.ExplicitInterfaceImplementations.Single();
Assert.Equal(interfaceProperty, explicitImpl);
}
public void Test1()
{
var assembly = MetadataTestHelpers.GetSymbolForReference(TestReferences.NetFx.v4_0_21006.mscorlib);
TestTypeKindHelper(assembly);
}
public void TestMixedAccessorModifiers()
{
var assembly = MetadataTestHelpers.GetSymbolForReference(TestReferences.SymbolsTests.Properties);
var globalNamespace = assembly.GlobalNamespace;
var type = globalNamespace.GetMember <NamedTypeSymbol>("AccessorModifierMismatch");
const VirtualnessModifiers @none = VirtualnessModifiers.None;
const VirtualnessModifiers @abstract = VirtualnessModifiers.Abstract;
const VirtualnessModifiers @virtual = VirtualnessModifiers.Virtual;
const VirtualnessModifiers @override = VirtualnessModifiers.Override;
const VirtualnessModifiers @sealed = VirtualnessModifiers.Sealed;
VirtualnessModifiers[] modList = new[]
{
@none,
@abstract,
@virtual,
@override,
@sealed,
};
int length = 1 + modList.Cast <int>().Max();
VirtualnessModifiers[,] expected = new VirtualnessModifiers[length, length];
expected[(int)@none, (int)@none] = @none;
expected[(int)@none, (int)@abstract] = @abstract;
expected[(int)@none, (int)@virtual] = @virtual;
expected[(int)@none, (int)@override] = @override;
expected[(int)@none, (int)@sealed] = @override; //not both sealed
expected[(int)@abstract, (int)@none] = @abstract;
expected[(int)@abstract, (int)@abstract] = @abstract;
expected[(int)@abstract, (int)@virtual] = @abstract;
expected[(int)@abstract, (int)@override] = @abstract | @override;
expected[(int)@abstract, (int)@sealed] = @abstract | @override; //not both sealed
expected[(int)@virtual, (int)@none] = @virtual;
expected[(int)@virtual, (int)@abstract] = @abstract;
expected[(int)@virtual, (int)@virtual] = @virtual;
expected[(int)@virtual, (int)@override] = @override;
expected[(int)@virtual, (int)@sealed] = @override; //not both sealed
expected[(int)@override, (int)@none] = @override;
expected[(int)@override, (int)@abstract] = @override | @abstract;
expected[(int)@override, (int)@virtual] = @override;
expected[(int)@override, (int)@override] = @override;
expected[(int)@override, (int)@sealed] = @override; //not both sealed
expected[(int)@sealed, (int)@none] = @override; //not both sealed
expected[(int)@sealed, (int)@abstract] = @abstract | @override; //not both sealed
expected[(int)@sealed, (int)@virtual] = @override; //not both sealed
expected[(int)@sealed, (int)@override] = @override; //not both sealed
expected[(int)@sealed, (int)@sealed] = @sealed;
// Table should be symmetrical.
for (int i = 0; i < length; i++)
{
for (int j = 0; j < length; j++)
{
Assert.Equal(expected[i, j], expected[j, i]);
}
}
foreach (var mod1 in modList)
{
foreach (var mod2 in modList)
{
var property = type.GetMember <PropertySymbol>(mod1.ToString() + mod2.ToString());
var getter = property.GetMethod;
var setter = property.SetMethod;
Assert.Equal(mod1, GetVirtualnessModifiers(getter));
Assert.Equal(mod2, GetVirtualnessModifiers(setter));
Assert.Equal(expected[(int)mod1, (int)mod2], GetVirtualnessModifiers(property));
}
}
}
public void Test1()
{
var assembly = MetadataTestHelpers.GetSymbolForReference(TestReferences.NetFx.v4_0_21006.mscorlib);
var module0 = assembly.Modules[0];
var objectType = module0.GlobalNamespace.GetMembers("System").
OfType <NamespaceSymbol>().Single().
GetTypeMembers("Object").Single();
Assert.Equal(0, objectType.Arity);
Assert.Equal(0, objectType.TypeParameters.Length);
Assert.Equal(0, objectType.TypeArguments.Length);
assembly = MetadataTestHelpers.GetSymbolForReference(TestReferences.SymbolsTests.MDTestLib1);
module0 = assembly.Modules[0];
var varC1 = module0.GlobalNamespace.GetTypeMembers("C1").Single();
Assert.Equal(1, varC1.Arity);
Assert.Equal(1, varC1.TypeParameters.Length);
Assert.Equal(1, varC1.TypeArguments.Length);
var varC1_T = varC1.TypeParameters[0];
Assert.Equal(varC1_T, varC1.TypeArguments[0]);
Assert.NotNull(varC1_T.EffectiveBaseClassNoUseSiteDiagnostics);
Assert.Equal(assembly, varC1_T.ContainingAssembly);
Assert.Equal(module0.GlobalNamespace, varC1_T.ContainingNamespace); // Null(C1_T.ContainingNamespace)
Assert.Equal(varC1, varC1_T.ContainingSymbol);
Assert.Equal(varC1, varC1_T.ContainingType);
Assert.Equal(Accessibility.NotApplicable, varC1_T.DeclaredAccessibility);
Assert.Equal("C1_T", varC1_T.Name);
Assert.Equal("C1_T", varC1_T.ToTestDisplayString());
Assert.Equal(0, varC1_T.GetMembers().Length);
Assert.Equal(0, varC1_T.GetMembers("foo").Length);
Assert.Equal(0, varC1_T.GetTypeMembers().Length);
Assert.Equal(0, varC1_T.GetTypeMembers("foo").Length);
Assert.Equal(0, varC1_T.GetTypeMembers("foo", 1).Length);
Assert.False(varC1_T.HasConstructorConstraint);
Assert.False(varC1_T.HasReferenceTypeConstraint);
Assert.False(varC1_T.HasValueTypeConstraint);
Assert.Equal(0, varC1_T.EffectiveInterfacesNoUseSiteDiagnostics.Length);
Assert.True(varC1_T.IsDefinition);
Assert.False(varC1_T.IsAbstract);
Assert.False(varC1_T.IsNamespace);
Assert.False(varC1_T.IsSealed);
Assert.False(varC1_T.IsVirtual);
Assert.False(varC1_T.IsOverride);
Assert.False(varC1_T.IsStatic);
Assert.True(varC1_T.IsType);
Assert.Equal(SymbolKind.TypeParameter, varC1_T.Kind);
Assert.Equal(0, varC1_T.Ordinal);
Assert.Equal(varC1_T, varC1_T.OriginalDefinition);
Assert.Equal(TypeKind.TypeParameter, varC1_T.TypeKind);
Assert.Equal(VarianceKind.None, varC1_T.Variance);
Assert.Same(module0, varC1_T.Locations.Single().MetadataModule);
Assert.Equal(0, varC1_T.ConstraintTypes.Length);
var varC2 = varC1.GetTypeMembers("C2").Single();
Assert.Equal(1, varC2.Arity);
Assert.Equal(1, varC2.TypeParameters.Length);
Assert.Equal(1, varC2.TypeArguments.Length);
var varC2_T = varC2.TypeParameters[0];
Assert.Equal("C2_T", varC2_T.Name);
Assert.Equal(varC2, varC2_T.ContainingType);
var varC3 = varC1.GetTypeMembers("C3").Single();
Assert.Equal(0, varC3.Arity);
Assert.Equal(0, varC3.TypeParameters.Length);
Assert.Equal(0, varC3.TypeArguments.Length);
var varC4 = varC3.GetTypeMembers("C4").Single();
Assert.Equal(1, varC4.Arity);
Assert.Equal(1, varC4.TypeParameters.Length);
Assert.Equal(1, varC4.TypeArguments.Length);
var varC4_T = varC4.TypeParameters[0];
Assert.Equal("C4_T", varC4_T.Name);
Assert.Equal(varC4, varC4_T.ContainingType);
var varTC2 = module0.GlobalNamespace.GetTypeMembers("TC2").Single();
Assert.Equal(2, varTC2.Arity);
Assert.Equal(2, varTC2.TypeParameters.Length);
Assert.Equal(2, varTC2.TypeArguments.Length);
var varTC2_T1 = varTC2.TypeParameters[0];
var varTC2_T2 = varTC2.TypeParameters[1];
Assert.Equal(varTC2_T1, varTC2.TypeArguments[0]);
Assert.Equal(varTC2_T2, varTC2.TypeArguments[1]);
Assert.Equal("TC2_T1", varTC2_T1.Name);
Assert.Equal(varTC2, varTC2_T1.ContainingType);
Assert.Equal(0, varTC2_T1.Ordinal);
Assert.Equal("TC2_T2", varTC2_T2.Name);
Assert.Equal(varTC2, varTC2_T2.ContainingType);
Assert.Equal(1, varTC2_T2.Ordinal);
var varC100 = module0.GlobalNamespace.GetTypeMembers("C100").Single();
var varT = varC100.TypeParameters[0];
Assert.False(varT.HasConstructorConstraint);
Assert.False(varT.HasReferenceTypeConstraint);
Assert.False(varT.HasValueTypeConstraint);
Assert.Equal(VarianceKind.Out, varT.Variance);
var varC101 = module0.GlobalNamespace.GetTypeMembers("C101").Single();
varT = varC101.TypeParameters[0];
Assert.False(varT.HasConstructorConstraint);
Assert.False(varT.HasReferenceTypeConstraint);
Assert.False(varT.HasValueTypeConstraint);
Assert.Equal(VarianceKind.In, varT.Variance);
var varC102 = module0.GlobalNamespace.GetTypeMembers("C102").Single();
varT = varC102.TypeParameters[0];
Assert.True(varT.HasConstructorConstraint);
Assert.False(varT.HasReferenceTypeConstraint);
Assert.False(varT.HasValueTypeConstraint);
Assert.Equal(VarianceKind.None, varT.Variance);
Assert.Equal(0, varT.ConstraintTypes.Length);
var varC103 = module0.GlobalNamespace.GetTypeMembers("C103").Single();
varT = varC103.TypeParameters[0];
Assert.False(varT.HasConstructorConstraint);
Assert.True(varT.HasReferenceTypeConstraint);
Assert.False(varT.HasValueTypeConstraint);
Assert.Equal(VarianceKind.None, varT.Variance);
Assert.Equal(0, varT.ConstraintTypes.Length);
var varC104 = module0.GlobalNamespace.GetTypeMembers("C104").Single();
varT = varC104.TypeParameters[0];
Assert.False(varT.HasConstructorConstraint);
Assert.False(varT.HasReferenceTypeConstraint);
Assert.True(varT.HasValueTypeConstraint);
Assert.Equal(VarianceKind.None, varT.Variance);
Assert.Equal(0, varT.ConstraintTypes.Length);
var varC105 = module0.GlobalNamespace.GetTypeMembers("C105").Single();
varT = varC105.TypeParameters[0];
Assert.True(varT.HasConstructorConstraint);
Assert.True(varT.HasReferenceTypeConstraint);
Assert.False(varT.HasValueTypeConstraint);
Assert.Equal(VarianceKind.None, varT.Variance);
var varC106 = module0.GlobalNamespace.GetTypeMembers("C106").Single();
varT = varC106.TypeParameters[0];
Assert.True(varT.HasConstructorConstraint);
Assert.True(varT.HasReferenceTypeConstraint);
Assert.False(varT.HasValueTypeConstraint);
Assert.Equal(VarianceKind.Out, varT.Variance);
var varI101 = module0.GlobalNamespace.GetTypeMembers("I101").Single();
var varI102 = module0.GlobalNamespace.GetTypeMembers("I102").Single();
var varC201 = module0.GlobalNamespace.GetTypeMembers("C201").Single();
varT = varC201.TypeParameters[0];
Assert.Equal(1, varT.ConstraintTypes.Length);
Assert.Same(varI101, varT.ConstraintTypes.ElementAt(0));
var localC202 = module0.GlobalNamespace.GetTypeMembers("C202").Single();
varT = localC202.TypeParameters[0];
Assert.Equal(2, varT.ConstraintTypes.Length);
Assert.Same(varI101, varT.ConstraintTypes.ElementAt(0));
Assert.Same(varI102, varT.ConstraintTypes.ElementAt(1));
}
public void Test1()
{
var assembly = MetadataTestHelpers.GetSymbolForReference(TestReferences.NetFx.v4_0_21006.mscorlib);
TestTypeAccessibilityHelper(assembly.Modules[0]);
}
public void Test1()
{
var assembly = MetadataTestHelpers.GetSymbolForReference(Net40.mscorlib);
TestTypeKindHelper(assembly);
}
