public void AssignmentTest()
{
SetupDefaultEnclosingMethod(
VarDecl("i", Type("I")),
Assign("i", Invoke("this", Method(Type("I"), DefaultClassContext, "M"))),
InvokeStmt("i", SomeMethodOnType("I")));
AssertQueriesInDefault(
new Query
{
type = DefaultClassContext.ToCoReName(),
definition = DefinitionSites.CreateDefinitionByThis(),
sites =
{
CallSites.CreateReceiverCallSite(Method(Type("I"), DefaultClassContext, "M"))
}
},
new Query
{
type = Type("I").ToCoReName(),
definition = DefinitionSites.CreateDefinitionByReturn(Method(Type("I"), DefaultClassContext, "M")),
sites =
{
SomeCallSiteOnType("I")
}
}
);
}
public override DefinitionSite Visit(IInvocationExpression entity,
UsageContext context)
{
try
{
// TODO @seb: fix analysis and then remove this fix
if (Equals("", entity.MethodName.Name))
{
return(DefinitionSites.CreateUnknownDefinitionSite());
}
if (entity.MethodName.IsConstructor)
{
return(DefinitionSites.CreateDefinitionByConstructor(entity.MethodName));
}
return(DefinitionSites.CreateDefinitionByReturn(entity.MethodName));
}
catch (Exception e)
{
// TODO @seb: untested!
Console.WriteLine("UsageDefinitionVisitor: caught exception, falling back to unknown DefinitionSite");
return(DefinitionSites.CreateUnknownDefinitionSite());
}
}
public void ShouldRecognizeEqualQuerys()
{
var expected = new Query
{
type = new CoReTypeName("LType"),
definition = DefinitionSites.CreateDefinitionByReturn("LFactory.method()LType;"),
classCtx = new CoReTypeName("LClass"),
methodCtx = new CoReMethodName("LReceiver.method(LArgument;)LReturn;")
};
expected.sites.Add(CallSites.CreateParameterCallSite("LReceiver.method(LType;)LReturn;", 3));
expected.sites.Add(CallSites.CreateParameterCallSite("LType.method(LArgument;)LReturn;", 0));
var actual = new Query
{
type = new CoReTypeName("LType"),
definition = DefinitionSites.CreateDefinitionByReturn("LFactory.method()LType;"),
classCtx = new CoReTypeName("LClass"),
methodCtx = new CoReMethodName("LReceiver.method(LArgument;)LReturn;")
};
actual.sites.Add(CallSites.CreateParameterCallSite("LReceiver.method(LType;)LReturn;", 3));
actual.sites.Add(CallSites.CreateParameterCallSite("LType.method(LArgument;)LReturn;", 0));
Assert.AreEqual(expected, actual);
}
public void MethodReturnDefinition()
{
const string name = "LType.M()LType;";
var definition = DefinitionSites.CreateDefinitionByReturn(name);
var actual = SmilePBNRecommenderConstants.NewDefinition(definition);
var expected = string.Format("RETURN:{0}", name);
Assert.AreEqual(expected, actual);
}
public void MethodReturnDefinitionIsCorrectInitialized()
{
var actual = DefinitionSites.CreateDefinitionByReturn("LStrangeType.M()LType;");
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.RETURN,
method = new CoReMethodName("LStrangeType.M()LType;")
};
Assert.AreEqual(expected, actual);
}
public void MethodReturnByMethodNameDefinitionIsCorrectInitialized()
{
var methodName = Names.Method("[RType,P1] [Decl,P1].MethodName()");
var actual = DefinitionSites.CreateDefinitionByReturn(methodName);
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.RETURN,
method = methodName.ToCoReName()
};
Assert.AreEqual(expected, actual);
}
public void ShouldSetEvidenceOnDefinitionSite()
{
var query = Fix.CreateDefaultQuery();
query.definition = DefinitionSites.CreateDefinitionByReturn("LType.Create()LType;");
_uut.Query(query);
var expected = SmilePBNRecommender.ConvertToLegalSmileName("RETURN:LType.Create()LType;");
var actual = _network.GetEvidenceId(Constants.DefinitionTitle);
Assert.AreEqual(expected, actual);
}
public void ShouldNotSetEvidencesOnNotMatchingQuery()
{
var query = Fix.CreateDefaultQuery();
query.definition = DefinitionSites.CreateDefinitionByReturn("LStrangeType.M()LType;");
query.sites.Add(CallSites.CreateReceiverCallSite("LStrangeType.M()LType;"));
_uut.Query(query);
var actual = _network.GetAllNodes().All(id => !_network.IsEvidence(id));
Assert.IsTrue(actual);
}
public void VarDefinitionByReturn_ReturnsSubtype()
{
var callee = Method(Type("B"), DefaultClassContext, "M");
SetupDefaultEnclosingMethod(
VarDecl("a", Type("A")),
Assign("a", Invoke("this", callee)),
InvokeStmt("a", SomeMethodOnType("A")));
AssertQueriesExistFor(Type("A"), DefaultClassContext);
var actual = FindQueryWith(Type("A")).definition;
var expected = DefinitionSites.CreateDefinitionByReturn(callee);
Assert.AreEqual(expected, actual);
}
private static DefinitionSite DefinitionByReturn(string methodName, ITypeName returnType)
{
return(DefinitionSites.CreateDefinitionByReturn(Method(returnType, methodName)));
}
