public void ShouldParseAssembly(string delegateId, string delegateTypeId)
{
var actual = new DelegateTypeName(delegateId).Assembly;
var expected = TypeUtils.CreateTypeName(delegateTypeId).Assembly;
Assert.AreEqual(expected, actual);
}
public void ShouldParseReturnType(string delegateId, string returnTypeId)
{
var actual = new DelegateTypeName(delegateId).ReturnType;
var expected = TypeUtils.CreateTypeName(returnTypeId);
Assert.AreEqual(expected, actual);
}
public void TypeClassification(string delegateId, string delegateTypeId)
{
var delegateType = new DelegateTypeName(delegateId);
Assert.IsTrue(delegateType.IsDelegateType);
Assert.IsTrue(delegateType.IsReferenceType);
if (!delegateType.Identifier.StartsWith("d:[?]"))
{
Assert.IsFalse(delegateType.IsUnknown);
}
Assert.IsFalse(delegateType.IsHashed);
var dt = delegateType.DelegateType;
Assert.AreEqual(dt.HasTypeParameters, delegateType.HasTypeParameters);
Assert.IsFalse(delegateType.IsArray);
Assert.IsFalse(delegateType.IsTypeParameter);
Assert.IsFalse(delegateType.IsPredefined);
Assert.IsFalse(delegateType.IsClassType);
Assert.IsFalse(delegateType.IsEnumType);
Assert.IsFalse(delegateType.IsInterfaceType);
Assert.IsFalse(delegateType.IsNullableType);
Assert.IsFalse(delegateType.IsSimpleType);
Assert.IsFalse(delegateType.IsStructType);
Assert.IsFalse(delegateType.IsTypeParameter);
Assert.IsFalse(delegateType.IsValueType);
Assert.IsFalse(delegateType.IsVoidType);
}
public void ShouldApplyV0NameFixes()
{
var actual = "0T:d:T,P".Deserialize <IDelegateTypeName>();
var expected = new DelegateTypeName("d:[?] [T,P].()");
Assert.AreEqual(expected, actual);
}
public void IsArrayName(string baseTypeId, string expected1DId, string expected2DId)
{
Assert.IsFalse(ArrayTypeName.IsArrayTypeNameIdentifier(baseTypeId));
foreach (var arrId in new[] { expected1DId, expected2DId })
{
if (TypeParameterName.IsTypeParameterNameIdentifier(baseTypeId))
{
Assert.IsTrue(TypeParameterName.IsTypeParameterNameIdentifier(arrId));
Assert.IsFalse(TypeName.IsTypeNameIdentifier(arrId));
Assert.IsFalse(ArrayTypeName.IsArrayTypeNameIdentifier(arrId));
Assert.IsFalse(DelegateTypeName.IsDelegateTypeNameIdentifier(arrId));
Assert.IsFalse(PredefinedTypeName.IsPredefinedTypeNameIdentifier(arrId));
Assert.IsFalse(TypeUtils.IsUnknownTypeIdentifier(arrId));
}
else if (PredefinedTypeName.IsPredefinedTypeNameIdentifier(baseTypeId))
{
Assert.IsTrue(PredefinedTypeName.IsPredefinedTypeNameIdentifier(arrId));
Assert.IsFalse(TypeName.IsTypeNameIdentifier(arrId));
Assert.IsFalse(ArrayTypeName.IsArrayTypeNameIdentifier(arrId));
Assert.IsFalse(TypeParameterName.IsTypeParameterNameIdentifier(arrId));
Assert.IsFalse(DelegateTypeName.IsDelegateTypeNameIdentifier(arrId));
Assert.IsFalse(TypeUtils.IsUnknownTypeIdentifier(arrId));
}
else
{
Assert.IsTrue(ArrayTypeName.IsArrayTypeNameIdentifier(arrId));
Assert.IsFalse(TypeName.IsTypeNameIdentifier(arrId));
Assert.IsFalse(TypeParameterName.IsTypeParameterNameIdentifier(arrId));
Assert.IsFalse(DelegateTypeName.IsDelegateTypeNameIdentifier(arrId));
Assert.IsFalse(PredefinedTypeName.IsPredefinedTypeNameIdentifier(arrId));
Assert.IsFalse(TypeUtils.IsUnknownTypeIdentifier(arrId));
}
}
}
public void TypeParameterParsingIsCached()
{
var sut = new DelegateTypeName("d:[?] [n.C+D`1[[T]], P].()");
var a = sut.TypeParameters;
var b = sut.TypeParameters;
Assert.AreSame(a, b);
}
public void RecursiveDelegates1_param()
{
const string id = "d:[?] [n.C+D, P].([n.C+D, P] p)";
var ps = new DelegateTypeName(id).Parameters;
Assert.AreEqual(1, ps.Count);
Assert.AreEqual(id, ps.First().ValueType.Identifier);
}
public void RecursiveDelegates1_return()
{
const string id = "d:[n.C+D, P] [n.C+D, P].()";
var a = new DelegateTypeName(id);
var b = a.ReturnType;
Assert.AreEqual(a, b);
}
public void RecursiveDelegates2_return()
{
const string id = "d:[T`1[[T -> n.C+D, P]], P] [n.C+D, P].()";
const string returnId = "T`1[[T -> d:[T`1[[T -> n.C+D, P]], P] [n.C+D, P].()]], P";
var a = new DelegateTypeName(id).ReturnType;
var b = TypeUtils.CreateTypeName(returnId);
Assert.AreEqual(a, b);
}
public void ShouldIdentifyValidTypeParameterNames(string typeParameter, string shortName, string boundType)
{
Assert.IsTrue(TypeParameterName.IsTypeParameterNameIdentifier(typeParameter));
Assert.IsFalse(DelegateTypeName.IsDelegateTypeNameIdentifier(typeParameter));
Assert.IsFalse(ArrayTypeName.IsArrayTypeNameIdentifier(typeParameter));
Assert.IsFalse(TypeUtils.IsUnknownTypeIdentifier(typeParameter));
Assert.IsFalse(PredefinedTypeName.IsPredefinedTypeNameIdentifier(typeParameter));
Assert.IsFalse(TypeName.IsTypeNameIdentifier(typeParameter));
}
public void ShouldRecognizeDelegateNames(string delegateId, string delegateTypeId)
{
Assert.IsTrue(DelegateTypeName.IsDelegateTypeNameIdentifier(delegateId));
Assert.IsFalse(TypeUtils.IsUnknownTypeIdentifier(delegateId));
Assert.IsFalse(ArrayTypeName.IsArrayTypeNameIdentifier(delegateId));
Assert.IsFalse(TypeParameterName.IsTypeParameterNameIdentifier(delegateId));
Assert.IsFalse(PredefinedTypeName.IsPredefinedTypeNameIdentifier(delegateId));
Assert.IsFalse(TypeName.IsTypeNameIdentifier(delegateId));
}
public void ShouldRecognizeIdentifier(string shortName, string fullName, string id)
{
Assert.IsTrue(PredefinedTypeName.IsPredefinedTypeNameIdentifier(id));
Assert.IsFalse(ArrayTypeName.IsArrayTypeNameIdentifier(id));
Assert.IsFalse(TypeUtils.IsUnknownTypeIdentifier(id));
Assert.IsFalse(TypeParameterName.IsTypeParameterNameIdentifier(id));
Assert.IsFalse(DelegateTypeName.IsDelegateTypeNameIdentifier(id));
Assert.IsFalse(TypeName.IsTypeNameIdentifier(id));
}
public void ShouldNotCrashForInvalidNames(string invalidId)
{
Assert.IsFalse(ArrayTypeName.IsArrayTypeNameIdentifier(invalidId));
Assert.IsFalse(TypeParameterName.IsTypeParameterNameIdentifier(invalidId));
Assert.IsFalse(DelegateTypeName.IsDelegateTypeNameIdentifier(invalidId));
Assert.IsFalse(PredefinedTypeName.IsPredefinedTypeNameIdentifier(invalidId));
Assert.IsFalse(TypeUtils.IsUnknownTypeIdentifier(invalidId));
Assert.IsFalse(TypeName.IsTypeNameIdentifier(invalidId));
}
public void RecursiveDelegates2_param()
{
const string id = "d:[?] [n.C+D, P].([T`1[[T -> n.C+D, P]], P] p)";
var paramId = "T`1[[T -> {0}]], P".FormatEx(id);
var ps = new DelegateTypeName(id).Parameters;
Assert.AreEqual(1, ps.Count);
Assert.AreEqual(paramId, ps.First().ValueType.Identifier);
}
public void ShouldRecognizeNonDelegateNames(string delegateId, string delegateTypeId)
{
if (DelegateTypeName.IsDelegateTypeNameIdentifier(delegateTypeId))
{
Assert.Ignore();
}
else
{
Assert.IsFalse(DelegateTypeName.IsDelegateTypeNameIdentifier(delegateTypeId));
}
}
public void ShouldParseParameters(string delegateId, string delegateTypeId)
{
if (!delegateId.EndsWith("()"))
{
var sut = new DelegateTypeName(delegateId);
Assert.IsTrue(sut.HasParameters);
}
else
{
Assert.Ignore();
}
}
public void ShouldRecognizeUnknownType()
{
foreach (var id in new[] { null, "", "?" })
{
Assert.IsTrue(TypeUtils.IsUnknownTypeIdentifier(id));
Assert.IsFalse(TypeName.IsTypeNameIdentifier(id));
Assert.IsFalse(ArrayTypeName.IsArrayTypeNameIdentifier(id));
Assert.IsFalse(DelegateTypeName.IsDelegateTypeNameIdentifier(id));
Assert.IsFalse(TypeParameterName.IsTypeParameterNameIdentifier(id));
Assert.IsFalse(PredefinedTypeName.IsPredefinedTypeNameIdentifier(id));
}
}
public void ShouldRecognizeRegularTypes(string typeId,
string assemblyId,
string namespaceId,
string fullName,
string name)
{
Assert.IsFalse(TypeUtils.IsUnknownTypeIdentifier(typeId));
Assert.IsFalse(ArrayTypeName.IsArrayTypeNameIdentifier(typeId));
Assert.IsFalse(DelegateTypeName.IsDelegateTypeNameIdentifier(typeId));
Assert.IsFalse(TypeParameterName.IsTypeParameterNameIdentifier(typeId));
Assert.IsFalse(PredefinedTypeName.IsPredefinedTypeNameIdentifier(typeId));
Assert.IsTrue(TypeName.IsTypeNameIdentifier(typeId));
}
public void RecursiveDelegates_unknown()
{
const string id = "d:[?] [?].([?] p)";
var sut = new DelegateTypeName(id);
Assert.IsFalse(sut.IsRecursive);
var rt = sut.ReturnType;
Assert.AreEqual("?", rt.Identifier);
var ps = sut.Parameters;
Assert.AreEqual(1, ps.Count);
Assert.AreEqual("[?] p", ps[0].Identifier);
}
public void ArraysAreNothingElse(string baseTypeId, string expected1DId, string expected2DId)
{
foreach (var id in new[] { expected1DId, expected2DId })
{
var sut = TypeUtils.CreateTypeName(id);
Assert.IsFalse(sut.IsClassType);
Assert.IsFalse(sut.IsDelegateType);
Assert.IsFalse(sut.IsEnumType);
Assert.IsFalse(sut.IsInterfaceType);
Assert.IsFalse(sut.IsNestedType);
Assert.IsFalse(sut.IsNullableType);
Assert.IsTrue(sut.IsReferenceType);
Assert.IsTrue(sut.IsArray);
Assert.IsFalse(sut.IsSimpleType);
Assert.IsFalse(sut.IsStructType);
Assert.IsFalse(sut.IsValueType);
Assert.IsFalse(sut.IsVoidType);
Assert.IsFalse(sut.IsTypeParameter);
Assert.IsFalse(sut.IsDelegateType);
Assert.IsFalse(sut.IsPredefined);
Assert.IsFalse(TypeName.IsTypeNameIdentifier(id));
Assert.IsFalse(TypeUtils.IsUnknownTypeIdentifier(id));
Assert.IsFalse(DelegateTypeName.IsDelegateTypeNameIdentifier(id));
if (TypeParameterName.IsTypeParameterNameIdentifier(baseTypeId))
{
Assert.IsTrue(TypeParameterName.IsTypeParameterNameIdentifier(id));
}
if (PredefinedTypeName.IsPredefinedTypeNameIdentifier(baseTypeId))
{
Assert.IsTrue(PredefinedTypeName.IsPredefinedTypeNameIdentifier(id));
}
if (DelegateTypeName.IsDelegateTypeNameIdentifier(baseTypeId))
{
Assert.IsFalse(DelegateTypeName.IsDelegateTypeNameIdentifier(id));
}
}
}
private void AppendAssertsForTypeName(ITypeName t)
{
_sb.AppendLine("String id = \"{0}\";".FormatEx(t.Identifier));
_sb.Append("assertEquals(")
.AppendBool(TypeUtils.IsUnknownTypeIdentifier(t.Identifier))
.AppendLine(", TypeUtils.isUnknownTypeIdentifier(id));");
_sb.Append("assertEquals(")
.AppendBool(TypeName.IsTypeNameIdentifier(t.Identifier))
.AppendLine(", TypeName.isTypeNameIdentifier(id));");
_sb.Append("assertEquals(")
.AppendBool(ArrayTypeName.IsArrayTypeNameIdentifier(t.Identifier))
.AppendLine(", ArrayTypeName.isArrayTypeNameIdentifier(id));");
_sb.Append("assertEquals(")
.AppendBool(TypeParameterName.IsTypeParameterNameIdentifier(t.Identifier))
.AppendLine(", TypeParameterName.isTypeParameterNameIdentifier(id));");
_sb.Append("assertEquals(")
.AppendBool(DelegateTypeName.IsDelegateTypeNameIdentifier(t.Identifier))
.AppendLine(", DelegateTypeName.isDelegateTypeNameIdentifier(id));");
_sb.Append("assertEquals(")
.AppendBool(PredefinedTypeName.IsPredefinedTypeNameIdentifier(t.Identifier))
.AppendLine(", PredefinedTypeName.isPredefinedTypeNameIdentifier(id));");
_sb.AppendLine("ITypeName sut = TypeUtils.createTypeName(id);");
_sb.AppendLine("assertTrue(sut instanceof {0});".FormatEx(t.GetType().Name));
_sb.AppendAreEqual(t.IsHashed, "sut.isHashed()");
_sb.AppendAreEqual(t.IsUnknown, "sut.isUnknown()");
_sb.AppendAreEqual(t.Namespace, "sut.getNamespace()");
_sb.AppendAreEqual(t.Assembly, "sut.getAssembly()");
_sb.AppendAreEqual(t.FullName, "sut.getFullName()");
_sb.AppendAreEqual(t.Name, "sut.getName()");
_sb.AppendAreEqual(t.IsClassType, "sut.isClassType()");
_sb.AppendAreEqual(t.IsEnumType, "sut.isEnumType()");
_sb.AppendAreEqual(t.IsInterfaceType, "sut.isInterfaceType()");
_sb.AppendAreEqual(t.IsNullableType, "sut.isNullableType()");
_sb.AppendAreEqual(t.IsPredefined, "sut.isPredefined()");
_sb.AppendAreEqual(t.IsReferenceType, "sut.isReferenceType()");
_sb.AppendAreEqual(t.IsSimpleType, "sut.isSimpleType()");
_sb.AppendAreEqual(t.IsStructType, "sut.isStructType()");
_sb.AppendAreEqual(t.IsTypeParameter, "sut.isTypeParameter()");
_sb.AppendAreEqual(t.IsValueType, "sut.isValueType()");
_sb.AppendAreEqual(t.IsVoidType, "sut.isVoidType()");
_sb.AppendAreEqual(t.IsNestedType, "sut.isNestedType()");
_sb.AppendAreEqual(t.DeclaringType, "sut.getDeclaringType()");
_sb.AppendAreEqual(t.HasTypeParameters, "sut.hasTypeParameters()");
_sb.AppendAreEqual(t.TypeParameters, "sut.getTypeParameters()");
// used for several checks;
_sb.AppendLine("boolean hasThrown;");
// array
_sb.Comment("array");
_sb.AppendAreEqual(t.IsArray, "sut.isArray()");
if (t.IsArray)
{
var tArr = t.AsArrayTypeName;
_sb.AppendLine("IArrayTypeName sutArr = sut.asArrayTypeName();");
_sb.AppendAreEqual(tArr.Rank, "sutArr.getRank()");
_sb.AppendAreEqual(tArr.ArrayBaseType, "sutArr.getArrayBaseType()");
}
else
{
_sb.AppendThrowValidation("sut.asArrayTypeName();", "AssertionException");
}
// delegates
_sb.Comment("delegates");
_sb.AppendAreEqual(t.IsDelegateType, "sut.isDelegateType()");
if (t.IsDelegateType)
{
var tD = t.AsDelegateTypeName;
_sb.AppendLine("IDelegateTypeName sutD = sut.asDelegateTypeName();");
_sb.AppendAreEqual(tD.DelegateType, "sutD.getDelegateType()");
_sb.AppendAreEqual(tD.HasParameters, "sutD.hasParameters()");
_sb.AppendAreEqual(tD.IsRecursive, "sutD.isRecursive()");
_sb.AppendAreEqual(tD.Parameters, "sutD.getParameters()");
_sb.AppendAreEqual(tD.ReturnType, "sutD.getReturnType()");
}
else
{
_sb.AppendThrowValidation("sut.asDelegateTypeName();", "AssertionException");
}
// predefined
_sb.Comment("predefined");
_sb.AppendAreEqual(t.IsPredefined, "sut.isPredefined()");
if (t.IsPredefined)
{
var sutP = t.AsPredefinedTypeName;
_sb.AppendLine("IPredefinedTypeName sutP = sut.asPredefinedTypeName();");
_sb.AppendAreEqual(sutP.FullType, "sutP.getFullType()");
}
else
{
_sb.AppendThrowValidation("sut.asPredefinedTypeName();", "AssertionException");
}
// type parameters
_sb.Comment("type parameters");
_sb.AppendAreEqual(t.IsTypeParameter, "sut.isTypeParameter()");
if (t.IsTypeParameter)
{
var sutT = t.AsTypeParameterName;
_sb.AppendLine("ITypeParameterName sutT = sut.asTypeParameterName();");
_sb.AppendAreEqual(sutT.IsBound, "sutT.isBound()");
_sb.AppendAreEqual(sutT.TypeParameterShortName, "sutT.getTypeParameterShortName()");
_sb.AppendAreEqual(sutT.TypeParameterType, "sutT.getTypeParameterType()");
}
else
{
_sb.AppendThrowValidation("sut.asTypeParameterName();", "AssertionException");
}
}
