public void EqualsTargetTypeSameValue()
{
var type1 = CreateEqualsInterface <ITypeReference>("type name");
var type2 = CreateEqualsInterface <ITypeReference>("type name");
var type3 = CreateEqualsInterface <ITypeReference>("other type name");
Assert.True(type1.Object.Equals(type2.Object));
Assert.False(type1.Object.Equals(type3.Object));
Assert.True(object.Equals(type1.Object, type2.Object));
var value = UsedNamespaceOrType.CreateType(type1.Object, "alias");
var unit = EqualityUnit
.Create(value)
.WithEqualValues(
value,
UsedNamespaceOrType.CreateType(type1.Object, "alias"),
UsedNamespaceOrType.CreateType(type2.Object, "alias"))
.WithNotEqualValues(
UsedNamespaceOrType.CreateType(type1.Object, "different alias"),
UsedNamespaceOrType.CreateType(type2.Object, "different alias"),
UsedNamespaceOrType.CreateType(type3.Object, "alias"),
UsedNamespaceOrType.CreateNamespace(new Mock <INamespace>().Object));
RunAll(unit);
}
public void EqualsNamespaceAndAssembly()
{
var assembly1 = CreateEqualsInterface <IAssemblyReference>("assembly");
var assembly2 = CreateEqualsInterface <IAssemblyReference>("assembly");
var assembly3 = CreateEqualsInterface <IAssemblyReference>("other assembly");
var ns1 = CreateEqualsInterface <INamespace>("namespace");
var ns2 = CreateEqualsInterface <INamespace>("namespace");
var ns3 = CreateEqualsInterface <INamespace>("other namespace");
var value = UsedNamespaceOrType.CreateNamespace(ns1.Object, assembly1.Object);
var unit = EqualityUnit
.Create(value)
.WithEqualValues(
value,
UsedNamespaceOrType.CreateNamespace(ns1.Object, assembly1.Object),
UsedNamespaceOrType.CreateNamespace(ns1.Object, assembly2.Object),
UsedNamespaceOrType.CreateNamespace(ns2.Object, assembly1.Object)
)
.WithNotEqualValues(
UsedNamespaceOrType.CreateExternAlias("alias"),
UsedNamespaceOrType.CreateNamespace(
ns1.Object,
new Mock <IAssemblyReference>(MockBehavior.Strict).Object
),
UsedNamespaceOrType.CreateNamespace(ns3.Object)
);
RunAll(unit);
}
public void EqualsNamespace()
{
var ns1 = CreateEqualsInterface <INamespace>("namespace");
var ns2 = CreateEqualsInterface <INamespace>("namespace");
var ns3 = CreateEqualsInterface <INamespace>("other namespace");
var value = UsedNamespaceOrType.CreateNamespace(ns1.Object);
var unit = EqualityUnit
.Create(value)
.WithEqualValues(
value,
UsedNamespaceOrType.CreateNamespace(ns1.Object),
UsedNamespaceOrType.CreateNamespace(ns2.Object)
)
.WithNotEqualValues(
UsedNamespaceOrType.CreateExternAlias("alias"),
UsedNamespaceOrType.CreateNamespace(
ns1.Object,
CreateEqualsInterface <IAssemblyReference>("a").Object
),
UsedNamespaceOrType.CreateNamespace(ns3.Object)
);
RunAll(unit);
}
public void EqualsExternAlias()
{
var value = UsedNamespaceOrType.CreateExternAlias("alias1");
var unit = EqualityUnit
.Create(value)
.WithEqualValues(value, UsedNamespaceOrType.CreateExternAlias("alias1"))
.WithNotEqualValues(UsedNamespaceOrType.CreateExternAlias("alias2"));
RunAll(unit);
}
public void EqualsTargetTypeSameObject()
{
var ref1 = CreateEqualsInterface <ITypeReference>("ref1");
var ref2 = CreateEqualsInterface <ITypeReference>("ref2");
var value = UsedNamespaceOrType.CreateType(ref1.Object, "alias");
var unit = EqualityUnit
.Create(value)
.WithEqualValues(
value,
UsedNamespaceOrType.CreateType(ref1.Object, "alias"))
.WithNotEqualValues(
UsedNamespaceOrType.CreateNamespace(new Mock <INamespace>().Object),
UsedNamespaceOrType.CreateType(ref2.Object, "alias"),
UsedNamespaceOrType.CreateType(ref1.Object, "different alias"));
RunAll(unit);
}
private ImmutableArray <NamespaceScope> BuildNamespaceScopes(ConsList <Imports> debugImports)
{
ArrayBuilder <NamespaceScope> namespaceScopes = ArrayBuilder <NamespaceScope> .GetInstance();
foreach (Imports imports in debugImports)
{
ArrayBuilder <UsedNamespaceOrType> usedNamespaces = ArrayBuilder <UsedNamespaceOrType> .GetInstance();
// NOTE: order based on dev10: extern aliases, then usings, then aliases namespaces and types
ImmutableArray <AliasAndExternAliasDirective> externAliases = imports.ExternAliases;
if (!externAliases.IsDefault)
{
foreach (var alias in externAliases)
{
usedNamespaces.Add(UsedNamespaceOrType.CreateCSharpExternNamespace(alias.Alias.Name));
}
}
ImmutableArray <NamespaceOrTypeAndUsingDirective> usings = imports.Usings;
if (!usings.IsDefault)
{
foreach (var nsOrType in usings)
{
NamespaceOrTypeSymbol namespaceOrType = nsOrType.NamespaceOrType;
if (namespaceOrType.IsNamespace)
{
NamespaceSymbol @namespace = (NamespaceSymbol)namespaceOrType;
string namespaceString = GetNamespaceOrTypeString(@namespace);
// TODO: incorrect, see bug #913022
string externAlias = GetExternAliases(@namespace).FirstOrDefault();
usedNamespaces.Add(UsedNamespaceOrType.CreateCSharpNamespace(namespaceString, externAlias));
}
else
{
// This is possible in C# scripts, but the EE doesn't support the meaning intended by script files.
// Specifically, when a script includes "using System.Console;" the intended meaning is that the
// static methods of System.Console are available but System.Console itself is not. Even if we output
// "TSystem.Console" - which the EE may or may not support - we would only see System.Console become
// available.
}
}
}
Dictionary <string, AliasAndUsingDirective> aliasSymbols = imports.UsingAliases;
if (aliasSymbols != null)
{
foreach (var pair in aliasSymbols)
{
var alias = pair.Key;
var symbol = pair.Value.Alias;
Debug.Assert(!symbol.IsExtern);
var target = symbol.Target;
var targetString = GetNamespaceOrTypeString(target);
if (target.Kind == SymbolKind.Namespace)
{
// TODO: incorrect, see bug #913022
string externAlias = GetExternAliases((NamespaceSymbol)target).FirstOrDefault();
usedNamespaces.Add(UsedNamespaceOrType.CreateCSharpNamespaceAlias(targetString, alias, externAlias));
}
else
{
Debug.Assert(target is TypeSymbol);
usedNamespaces.Add(UsedNamespaceOrType.CreateCSharpTypeAlias(targetString, alias));
}
}
}
namespaceScopes.Add(new NamespaceScope(usedNamespaces.ToImmutableAndFree()));
}
return(namespaceScopes.ToImmutableAndFree()); //NOTE: inner-to-outer order matches dev10
}
