private void GatherDebuggingInfoFromInsufficiency(IExecutionNode executionNode, TermManager termManager,
Term condition, TypeEx explorableType)
{
var sb = new SafeStringBuilder();
sb.AppendLine("condition:");
sb.AppendLine();
this.tba.ConvertTermToText(new SafeStringWriter(sb), condition, this.ExplorationServices.TermManager);
sb.AppendLine();
var swriter = new TermSExpWriter(termManager, new SafeStringWriter(sb), true, false);
swriter.Write(condition);
sb.AppendLine();
sb.AppendLine("location:");
sb.AppendLine();
sb.AppendLine(executionNode.CodeLocation.ToString());
sb.AppendLine();
sb.AppendLine("properties:");
Term unnegatedCondition;
if (termManager.TryGetInnerLogicallyNegatedValue(condition, out unnegatedCondition))
{
sb.AppendLine("negated");
}
else
{
unnegatedCondition = condition;
}
var targetFieldValues = new SafeDictionary <Field, object>();
Term left, right;
BinaryOperator binOp;
if (termManager.TryGetBinary(unnegatedCondition, out binOp, out left, out right))
{
sb.AppendFormat("binary relation: {0}", binOp);
sb.AppendLine();
if (!termManager.IsValue(left) && !termManager.IsValue(right))
{
sb.AppendLine("No constant on either left side or right side.");
return;
}
Term non_constant_term = null;
Term constant_term = null;
if (termManager.IsValue(left))
{
non_constant_term = right;
constant_term = left;
}
else if (termManager.IsValue(right))
{
non_constant_term = left;
constant_term = right;
}
sb.AppendLine("against constant");
if (constant_term == null || termManager.IsDefaultValue(constant_term))
{
sb.AppendLine("against default value ('null' for references)");
}
int value;
if (constant_term != null && termManager.TryGetI4Constant(constant_term, out value))
{
sb.AppendLine("against integer: " + value);
}
Term objectValue;
ObjectProperty objectProperty;
if (constant_term != null && termManager.TryGetObjectProperty(constant_term, out objectValue, out objectProperty))
{
sb.AppendLine("against object property: object=" + objectValue + ", property=" + objectProperty);
}
sb.AppendLine(" involving fields: ");
SafeDictionary <Field, FieldValueHolder> innerFieldValues;
SafeList <TypeEx> innerFieldTypes;
SafeList <Field> fs = TargetBranchAnalyzer.GetInvolvedFields(this, termManager,
non_constant_term, out innerFieldValues, out innerFieldTypes);
foreach (var f in fs)
{
sb.AppendLine(f.FullName);
}
}
sb.AppendLine("Executed method call sequence");
if (this.pmd.LastExecutedFactoryMethodCallSequence != null)
{
foreach (var m in this.pmd.LastExecutedFactoryMethodCallSequence)
{
sb.AppendLine("\t" + m);
}
}
this.Log.Dump("foo", "insufficiency for " + (explorableType != null ? explorableType.FullName : "?"), sb.ToString());
return;
}
private void GatherDebuggingInfoFromInsufficiency(IExecutionNode executionNode, TermManager termManager,
Term condition, TypeEx explorableType)
{
var sb = new SafeStringBuilder();
sb.AppendLine("condition:");
sb.AppendLine();
this.tba.ConvertTermToText(new SafeStringWriter(sb), condition, this.ExplorationServices.TermManager);
sb.AppendLine();
var swriter = new TermSExpWriter(termManager, new SafeStringWriter(sb), true, false);
swriter.Write(condition);
sb.AppendLine();
sb.AppendLine("location:");
sb.AppendLine();
sb.AppendLine(executionNode.CodeLocation.ToString());
sb.AppendLine();
sb.AppendLine("properties:");
Term unnegatedCondition;
if (termManager.TryGetInnerLogicallyNegatedValue(condition, out unnegatedCondition))
sb.AppendLine("negated");
else
unnegatedCondition = condition;
var targetFieldValues = new SafeDictionary<Field, object>();
Term left, right;
BinaryOperator binOp;
if (termManager.TryGetBinary(unnegatedCondition, out binOp, out left, out right))
{
sb.AppendFormat("binary relation: {0}", binOp);
sb.AppendLine();
if (!termManager.IsValue(left) && !termManager.IsValue(right))
{
sb.AppendLine("No constant on either left side or right side.");
return;
}
Term non_constant_term = null;
Term constant_term = null;
if (termManager.IsValue(left))
{
non_constant_term = right;
constant_term = left;
}
else if (termManager.IsValue(right))
{
non_constant_term = left;
constant_term = right;
}
sb.AppendLine("against constant");
if (constant_term == null || termManager.IsDefaultValue(constant_term))
{
sb.AppendLine("against default value ('null' for references)");
}
int value;
if (constant_term != null && termManager.TryGetI4Constant(constant_term, out value))
{
sb.AppendLine("against integer: " + value);
}
Term objectValue;
ObjectProperty objectProperty;
if (constant_term != null && termManager.TryGetObjectProperty(constant_term, out objectValue, out objectProperty))
{
sb.AppendLine("against object property: object=" + objectValue + ", property=" + objectProperty);
}
sb.AppendLine(" involving fields: ");
SafeDictionary<Field, FieldValueHolder> innerFieldValues;
SafeList<TypeEx> innerFieldTypes;
SafeList<Field> fs = TargetBranchAnalyzer.GetInvolvedFields(this, termManager,
non_constant_term, out innerFieldValues, out innerFieldTypes);
foreach (var f in fs)
{
sb.AppendLine(f.FullName);
}
}
sb.AppendLine("Executed method call sequence");
if(this.pmd.LastExecutedFactoryMethodCallSequence != null)
foreach (var m in this.pmd.LastExecutedFactoryMethodCallSequence)
{
sb.AppendLine("\t" + m);
}
this.Log.Dump("foo", "insufficiency for " + (explorableType != null ? explorableType.FullName : "?"), sb.ToString());
return;
}
/// <summary>
/// OBSOLETE: Handles a scenario where there is a term in the condition
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <param name="binOp"></param>
/// <param name="fmt"></param>
private void handleAConstantInTerm(TermManager termManager, Term left, Term right,
BinaryOperator binOp, bool bNegated, SafeDictionary <Field, FieldValueHolder> fieldValues, Field culpritField,
out FieldModificationType fmt, out int fitnessval)
{
fitnessval = Int32.MaxValue;
fmt = FieldModificationType.UNKNOWN;
Term non_constant_term = null;
Term constant_term = null;
bool bleftRightMaintainted = true;
if (termManager.IsValue(left))
{
non_constant_term = right;
constant_term = left;
bleftRightMaintainted = true;
}
else if (termManager.IsValue(right))
{
non_constant_term = left;
constant_term = right;
bleftRightMaintainted = false;
}
int value;
if (termManager.TryGetI4Constant(constant_term, out value))
{
fmt = FieldModificationType.INCREMENT;
FieldValueHolder fvh;
if (fieldValues.TryGetValue(culpritField, out fvh))
{
int non_constant_field_value = fvh.intValue; //TODO: Assuming that the fieldType is Int32
if (bleftRightMaintainted)
{
fitnessval = FitnessMeasure.ComputeFitnessValue(this.host, binOp, value, non_constant_field_value, bNegated);
}
else
{
fitnessval = FitnessMeasure.ComputeFitnessValue(this.host, binOp, non_constant_field_value, value, bNegated);
}
}
else
{
this.host.Log.LogWarning(WikiTopics.MissingWikiTopic, "fitness measure",
"Failed to retrieve value for field " + culpritField.ToString());
}
}
else if (termManager.IsDefaultValue(constant_term))
{
if (binOp == BinaryOperator.Ceq)
{
if (culpritField.Type.ToString() == "System.Boolean")
{
fmt = bNegated ? FieldModificationType.TRUE_SET : FieldModificationType.FALSE_SET;
}
else
{
fmt = bNegated ? FieldModificationType.NON_NULL_SET : FieldModificationType.NULL_SET;
}
}
}
Term objectValue;
ObjectProperty objectProperty;
if (termManager.TryGetObjectProperty(constant_term, out objectValue, out objectProperty))
{
//TODO??? How to handle this scenario?
}
}
/// <summary>
/// OBSOLETE: Handles a scenario where there is a term in the condition
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <param name="binOp"></param>
/// <param name="fmt"></param>
private void handleAConstantInTerm(TermManager termManager, Term left, Term right,
BinaryOperator binOp, bool bNegated, SafeDictionary<Field, FieldValueHolder> fieldValues, Field culpritField,
out FieldModificationType fmt, out int fitnessval)
{
fitnessval = Int32.MaxValue;
fmt = FieldModificationType.UNKNOWN;
Term non_constant_term = null;
Term constant_term = null;
bool bleftRightMaintainted = true;
if (termManager.IsValue(left))
{
non_constant_term = right;
constant_term = left;
bleftRightMaintainted = true;
}
else if (termManager.IsValue(right))
{
non_constant_term = left;
constant_term = right;
bleftRightMaintainted = false;
}
int value;
if (termManager.TryGetI4Constant(constant_term, out value))
{
fmt = FieldModificationType.INCREMENT;
FieldValueHolder fvh;
if (fieldValues.TryGetValue(culpritField, out fvh))
{
int non_constant_field_value = fvh.intValue; //TODO: Assuming that the fieldType is Int32
if (bleftRightMaintainted)
fitnessval = FitnessMeasure.ComputeFitnessValue(this.host, binOp, value, non_constant_field_value, bNegated);
else
fitnessval = FitnessMeasure.ComputeFitnessValue(this.host, binOp, non_constant_field_value, value, bNegated);
}
else
this.host.Log.LogWarning(WikiTopics.MissingWikiTopic, "fitness measure",
"Failed to retrieve value for field " + culpritField.ToString());
}
else if (termManager.IsDefaultValue(constant_term))
{
if (binOp == BinaryOperator.Ceq)
{
if (culpritField.Type.ToString() == "System.Boolean")
{
fmt = bNegated ? FieldModificationType.TRUE_SET : FieldModificationType.FALSE_SET;
}
else
fmt = bNegated ? FieldModificationType.NON_NULL_SET : FieldModificationType.NULL_SET;
}
}
Term objectValue;
ObjectProperty objectProperty;
if (termManager.TryGetObjectProperty(constant_term, out objectValue, out objectProperty))
{
//TODO??? How to handle this scenario?
}
}