public void ShouldReplaceShortNameArrays(string shortName, string fullName)
{
var actual = BuiltInTypeAliases.GetFullTypeNameFromTypeAlias(fullName + "[]");
var expected = "{0}[]".FormatEx(fullName);
Assert.AreEqual(expected, actual);
}
public void ShouldReplaceShortNameNullables(string shortName, string fullName)
{
var actual = BuiltInTypeAliases.GetFullTypeNameFromTypeAlias(fullName + "?");
var expected = "System.Nullable`1[[T -> {0}]]".FormatEx(fullName);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Appends the name (and only the name!) of a type to the context.
/// </summary>
/// <param name="typeName">The type name to append.</param>
/// <returns>The context after appending.</returns>
public virtual SSTPrintingContext TypeNameOnly(ITypeName typeName)
{
if (typeName.IsTypeParameter)
{
return(Text(typeName.AsTypeParameterName.TypeParameterShortName));
}
var translatedTypeName = BuiltInTypeAliases.GetTypeAliasFromFullTypeName(typeName.FullName);
return(Text(translatedTypeName == typeName.FullName ? typeName.Name : translatedTypeName));
}
private static IType MockIType(string fqnOrAlias,
ISubstitution substitution,
string assemblyName,
string assemblyVersion)
{
var typeMock = new Mock <IDeclaredType>();
typeMock.Setup(t => t.Classify).Returns(TypeClassification.REFERENCE_TYPE);
var fqn = BuiltInTypeAliases.GetFullTypeNameFromTypeAlias(fqnOrAlias);
var mockTypeElement = MockTypeElement(fqn, assemblyName, assemblyVersion);
mockTypeElement.TypeParameters.AddRange(substitution.Domain);
typeMock.Setup(t => t.GetTypeElement()).Returns(mockTypeElement);
typeMock.Setup(t => t.GetLongPresentableName(CSharpLanguage.Instance)).Returns(fqnOrAlias);
typeMock.Setup(t => t.Assembly).Returns(MockAssemblyNameInfo(assemblyName, assemblyVersion));
var mockResolveResult = new Mock <IResolveResult>();
mockResolveResult.Setup(rr => rr.Substitution).Returns(substitution);
typeMock.Setup(t => t.Resolve()).Returns(mockResolveResult.Object);
return(typeMock.Object);
}
public void DoesNotTranslateTypesWithoutAlias()
{
var notAnAlias = BuiltInTypeAliases.GetTypeAliasFromFullTypeName("System.NotAnInt");
Assert.AreEqual("System.NotAnInt", notAnAlias);
}
public void TranslatesTypeBackToAlias()
{
var alias = BuiltInTypeAliases.GetTypeAliasFromFullTypeName("System.Int32");
Assert.AreEqual("int", alias);
}
public void ShouldReplaceAliasesInArrayTypes()
{
var arrayTypeName = BuiltInTypeAliases.GetFullTypeNameFromTypeAlias("long[]");
Assert.AreEqual("System.Int64[]", arrayTypeName);
}
public void ObjectShouldBeClassType()
{
var objectTypeName = BuiltInTypeAliases.GetFullTypeNameFromTypeAlias("object");
Assert.AreEqual("System.Object", objectTypeName);
}
public void ShouldBeNullableType()
{
var nullableTypeName = BuiltInTypeAliases.GetFullTypeNameFromTypeAlias("int?");
Assert.AreEqual("System.Nullable`1[[System.Int32]]", nullableTypeName);
}
public void ShouldBeValueTypeInt()
{
var intTypeName = BuiltInTypeAliases.GetFullTypeNameFromTypeAlias("int");
Assert.AreEqual("System.Int32", intTypeName);
}
public void ShouldBeVoidType()
{
var voidTypeName = BuiltInTypeAliases.GetFullTypeNameFromTypeAlias("void");
Assert.AreEqual("System.Void", voidTypeName);
}
public void ShouldKeepFullNameIfNotFound()
{
var actual = BuiltInTypeAliases.GetTypeAliasFromFullTypeName("x");
Assert.AreEqual("x", actual);
}
public void ShouldReplaceFullName(string shortName, string fullName)
{
var actual = BuiltInTypeAliases.GetTypeAliasFromFullTypeName(fullName);
Assert.AreEqual(shortName, actual);
}
public void ShouldKeepShortNameIfNotFound()
{
var actual = BuiltInTypeAliases.GetFullTypeNameFromTypeAlias("x");
Assert.AreEqual("x", actual);
}
