/// <summary>
/// Gets called when an un-explored branch is encountered during program execution
/// </summary>
/// <param name="executionNode"></param>
/// <param name="explorableType"></param>
public void LogExplorableInsufficiency(IExecutionNode executionNode, TypeEx explorableType)
{
var termManager = this.ExplorationServices.TermManager;
var condition = executionNode.SuccessorLabelToExplore;
this.GatherDebuggingInfoFromInsufficiency(executionNode, termManager, condition, explorableType);
this.tba.HandleTargetBranch(executionNode.CodeLocation, condition, termManager, explorableType);
}
/// <summary>
/// Includes what are the types supported
/// </summary>
/// <returns></returns>
public static bool IsPrimitiveType(TypeEx type)
{
if (type.IsPrimitiveImmutable || PrimitiveTypes.Contains(type) || type.IsStringType)
return true;
return false;
}
/// <summary>
/// Includes what are the types supported
/// </summary>
/// <returns></returns>
public static bool IsTypeSupported(TypeEx type)
{
if (type.Spec == TypeSpec.SzArray || type.IsPrimitiveImmutable || PrimitiveTypes.Contains(type) ||
type.IsStringType || type.Spec == TypeSpec.Class)
return true;
return false;
}
/// <summary>
/// Returns the loaded factory methods
/// </summary>
/// <param name="typeEx"></param>
/// <returns></returns>
public IEnumerable<PexExplorableCandidate> GetMSeqGenFactories(TypeEx typeEx)
{
SafeList<PexExplorableCandidate> existingList;
if (!this.recommendedFactories.TryGetValue(typeEx.FullName, out existingList))
yield break;
foreach (var factory in existingList)
yield return factory;
}
public bool TryGetTypeHints(TypeEx type,
out IIndexable<TypeDefinition> hints)
{
hints = null;
if (!PexMeConstants.ENABLE_TYPE_HINT_PROVIDER)
return false;
hints = null;
this.pmd.Log.LogMessage("Hint provider", "Requested for types of interface or class: " + type.FullName.ToString());
if (TypeAnalyzer.TryGetExtendingClasses(this.psd, type, out hints))
return true;
return false;
}
public PersistentUncoveredLocationStore(CodeLocation cl,
TypeEx explorableType, int termIndex, int fitnessvalue, FactorySuggestionStore fss)
{
this.CodeLocation = cl.ToString();
this.MethodSignature = MethodOrFieldAnalyzer.GetMethodSignature(cl.Method);
TypeDefinition declaringType;
if (!cl.Method.TryGetDeclaringType(out declaringType))
{
//TODO:Error
}
this.ExplorableType = explorableType.ToString();
this.Offset = cl.Offset;
this.AssemblyShortName = declaringType.Module.Assembly.Location;
this.declaringTypeStr = declaringType.ToString();
this.Fitnessvalue = fitnessvalue;
this.TermIndex = termIndex;
this.parentfss = fss;
}
public static bool HasFlag(this Enum value, Enum flag)
{
if (value == null)
{
throw new NullReferenceException();
}
if (flag == null)
{
throw new ArgumentNullException(nameof(flag));
}
var type = value.GetType();
if (flag.GetType() != type)
{
throw new ArgumentException("Enum types don't match");
}
var typeCode = TypeEx.GetTypeCode(type);
if (typeCode == TypeCode.Byte)
{
var byteFlag = Convert.ToByte(flag, CultureInfo.InvariantCulture);
return((Convert.ToByte(value, CultureInfo.InvariantCulture) & byteFlag) == byteFlag);
}
if (typeCode == TypeCode.Int16)
{
var int16Flag = Convert.ToInt16(flag, CultureInfo.InvariantCulture);
return((Convert.ToInt16(value, CultureInfo.InvariantCulture) & int16Flag) == int16Flag);
}
if (typeCode == TypeCode.Int32)
{
var int32Flag = Convert.ToInt32(flag, CultureInfo.InvariantCulture);
return((Convert.ToInt32(value, CultureInfo.InvariantCulture) & int32Flag) == int32Flag);
}
if (typeCode == TypeCode.Int64)
{
var int64Flag = Convert.ToInt64(flag, CultureInfo.InvariantCulture);
return((Convert.ToInt64(value, CultureInfo.InvariantCulture) & int64Flag) == int64Flag);
}
if (typeCode == TypeCode.SByte)
{
var sbyteFlag = Convert.ToSByte(flag, CultureInfo.InvariantCulture);
return((Convert.ToSByte(value, CultureInfo.InvariantCulture) & sbyteFlag) == sbyteFlag);
}
if (typeCode == TypeCode.UInt16)
{
var uint16Flag = Convert.ToUInt16(flag, CultureInfo.InvariantCulture);
return((Convert.ToUInt16(value, CultureInfo.InvariantCulture) & uint16Flag) == uint16Flag);
}
if (typeCode == TypeCode.UInt32)
{
var uint32Flag = Convert.ToUInt32(flag, CultureInfo.InvariantCulture);
return((Convert.ToUInt32(value, CultureInfo.InvariantCulture) & uint32Flag) == uint32Flag);
}
if (typeCode == TypeCode.UInt64)
{
var uint64Flag = Convert.ToUInt64(flag, CultureInfo.InvariantCulture);
return((Convert.ToUInt64(value, CultureInfo.InvariantCulture) & uint64Flag) == uint64Flag);
}
throw new InvalidOperationException("The underlying type of the Enum is not a recognized primitive integer type.");
}
private static TypeEx AddFieldToMethodEffects(IPexComponent host, TypeEx declaringType, SafeSet<Field> res,
SafeSet<Field> directSetFields,
SafeDictionary<Field, FieldModificationType> modificationTypeDic,
OpCode prevOpcode, Field field, TypeEx fieldType)
{
SafeDebug.AssumeNotNull(field, "field");
SafeDebug.Assume(!field.IsStatic, "!field.IsStatic");
TypeEx fieldDeclaringType;
//The following check ensures that the field belongs to this class
//or its base classes
if (field.TryGetDeclaringType(out fieldDeclaringType) &&
declaringType.IsAssignableTo(fieldDeclaringType))
{
res.Add(field);
var fieldTypeStr = fieldType.ToString();
if (fieldTypeStr == "System.Int32" || fieldTypeStr == "System.Int64" || fieldTypeStr == "System.Int16")
{
if (prevOpcode == OpCodes.Add)
modificationTypeDic[field] = FieldModificationType.INCREMENT;
else if (prevOpcode == OpCodes.Sub)
modificationTypeDic[field] = FieldModificationType.DECREMENT;
else
host.Log.LogWarning(WikiTopics.MissingWikiTopic, "fieldmodificationtype",
"Encountered unknown modification type for integer type " + prevOpcode);
}
else
{
if (field.Type.IsReferenceType)
{
if (prevOpcode == OpCodes.Ldnull)
modificationTypeDic[field] = FieldModificationType.NULL_SET;
else if (prevOpcode == OpCodes.Newarr || prevOpcode == OpCodes.Newobj)
modificationTypeDic[field] = FieldModificationType.NON_NULL_SET;
else
host.Log.LogWarning(WikiTopics.MissingWikiTopic, "fieldmodificationtype",
"Encountered unknown modification type for reference type " + prevOpcode);
}
else if (fieldTypeStr == "System.Boolean")
{
if (prevOpcode == OpCodes.Ldc_I4_0)
modificationTypeDic[field] = FieldModificationType.FALSE_SET;
else if (prevOpcode == OpCodes.Ldc_I4_1)
modificationTypeDic[field] = FieldModificationType.TRUE_SET;
else
host.Log.LogWarning(WikiTopics.MissingWikiTopic, "fieldmodificationtype",
"Encountered unknown modification type for boolean type " + prevOpcode);
}
}
//A heuristic based approach for aliasing analysis for checking whether the field is directly
//assigned any parameters
if (LdArgOpCodes.Contains(prevOpcode))
directSetFields.Add(field);
}
return fieldDeclaringType;
}
/// <summary>
/// Accepts a type in the form "assemblyname#typename" and returns the type name
/// </summary>
/// <param name="Field"></param>
/// <returns></returns>
public static bool TryGetTypeExFromPersistentStringForm(IPexComponent host, string typename, out TypeEx typeEx)
{
typeEx = null;
var splitarr = typename.Split(new char[] { PexMeConstants.PexMePersistenceFormSeparator });
SafeDebug.Assume(splitarr.Length == 2, "Incorrect persistent store type name");
try
{
bool result = TryGetTypeExFromName(host, splitarr[0], splitarr[1], out typeEx);
if (typeEx == null || !result)
return false;
return true;
}
catch (Exception)
{
return false;
}
}
public override PexResultTracking GetResultTreatment(PexTrackingThread thread, int callId,
IMethodSignature methodSignature, TypeEx[] varArgTypes,
bool hasDerivedResult)
{
// track uninstrumented method calls
if (!hasDerivedResult)
{
var method = methodSignature as Method;
if (method.FullName.Equals(_trackMethod.FullName))
{
if (track)
{
Dump("start to track " + method.FullName);
TrackingMethods.Add(method);
return PexResultTracking.Track;
}
Dump("method " + method.FullName + " is not tracked!");
}
// IssueTrackDatabase db;
// if (host.TryGetService<IssueTrackDatabase>(out db))
// {
//// host.Log.Dump("size", "size", "uninstrumented methods: " + db.UnInstrumentedMethods.Count);
// foreach (var uninstrumentedMethod in db.UnInstrumentedMethods)
// {
//// host.Log.Dump("Method", "Method", "uninstrumented methods: " + uninstrumentedMethod.Method.FullName);
//// host.Log.Dump("Method", "Method2", "methods: " + method.Definition.FullName);
// if (uninstrumentedMethod.Method.FullName.Equals(method.FullName))
// {
//// host.Log.Dump("Method", "track", "track: " + method.Definition.FullName);
// if (TrackingMethods.Add(method))
// {
// return PexResultTracking.Track;
// }
// }
// }
// }
}
return PexResultTracking.ConcreteOrDerived;
}
/// <summary>
/// Tries to get a property that modifies the given field
/// </summary>
/// <param name="host"></param>
/// <param name="type"></param>
/// <param name="field"></param>
/// <param name="property"></param>
/// <returns></returns>
public static bool TryGetPropertyModifyingField(IPexComponent host, TypeEx type, Field field, out Property property)
{
foreach (Property prop in type.DeclaredProperties)
{
Method setter = prop.Setter;
if (setter == null)
continue;
MethodEffects me;
if (TryComputeMethodEffects(host, type, setter, null, out me) && me.WrittenInstanceFields.Contains(field.ShortName))
{
FieldModificationType fmt;
if (me.ModificationTypeDictionary.TryGetValue(field.ShortName, out fmt) && fmt != FieldModificationType.METHOD_CALL
&& fmt != FieldModificationType.UNKNOWN)
{
property = prop;
return true;
}
}
}
var baseType = type.BaseType;
if (baseType != null)
{
if (TryGetPropertyModifyingField(host, baseType, field, out property))
return true;
}
property = null;
return false;
}
public static bool TryGetTypeExFromName(IPexComponent host, string assemblyname, string typename, out TypeEx typeEx)
{
typeEx = null;
AssemblyEx assembly;
ReflectionHelper.TryLoadAssemblyEx(assemblyname, out assembly);
return TryGetTypeExFromName(host, assembly, typename, out typeEx);
}
/// <summary>
/// Gets the type definition of a field
/// </summary>
/// <param name="host"></param>
/// <param name="field"></param>
/// <param name="ftex"></param>
/// <returns></returns>
public static bool TryGetDeclaringTypeEx(IPexComponent host, Field field, out TypeEx ftex)
{
var fdefinition = field.Definition;
TypeDefinition td;
if (!fdefinition.TryGetDeclaringType(out td))
{
host.Log.LogError(WikiTopics.MissingWikiTopic, "fieldanalyzer",
"Failed to retrieve the declaring type of the field " + field.FullName);
ftex = null;
return false;
}
ftex = td.Instantiate(GetGenericTypeParameters(host, td));
return true;
}
/// <summary>
/// Returns true if the field is visible externally of the given type
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static bool IsFieldExternallyVisible(IPexComponent host, TypeEx type, Field field)
{
var visibilityContext = VisibilityContext.Exported;
//Step 1: Is field visible externally?
if (field.IsVisible(visibilityContext))
return true;
//Step 2: Check whether this is an associated property and see whether it is public
Property property;
if (TryGetPropertyModifyingField(host, type, field, out property))
{
if (property.IsVisible(visibilityContext))
return true;
}
//Step 3: Check whether any constructor directly sets this field
foreach (Method constructor in type.GetVisibleInstanceConstructors(visibilityContext))
{
MethodEffects me;
if (TryComputeMethodEffects(host, type, constructor, null, out me))
{
if (me.DirectSetterFields.Contains(field.ShortName))
return true;
}
}
return false;
}
/// <summary>
/// Given a type definition, this function gets the generic parameters
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static TypeEx[] GetGenericTypeParameters(IPexComponent host, TypeDefinition tdef)
{
TypeEx[] typErr = new TypeEx[tdef.GenericTypeParametersCount];
TypeEx inttype = MetadataFromReflection.GetType(typeof(int));
int count = 0;
foreach (var genp in tdef.GenericTypeParameters)
{
TypeEx predefTypeEx;
if (PreDefinedGenericClasses.TryGetInstantiatedClass(host, genp.Name, tdef, out predefTypeEx))
typErr[count] = predefTypeEx;
else
typErr[count] = inttype;
count++;
}
return typErr;
}
// Find out how many fields require user provided factory methods
public static bool GetTargetExplorableField(IEnumerable<Field> involvedFields, out Field targetField,
out TypeEx declaringType, IPexComponent host,out TypeEx targetType)
{
targetField = null;
var allInvolvedFields = new SafeList<Field>();
allInvolvedFields.AddRange(involvedFields);
int numFields = allInvolvedFields.Count;
if (numFields < 1)
{
declaringType = null;
targetType = null;
return false;
}
//
// if (numFields == 1)
// {
// targetField = allInvolvedFields[0];
// if (!MethodOrFieldAnalyzer.TryGetDeclaringTypeDefinition(host, targetField, out declaringType))
// {
// declaringType = null;
// return false;
// }
// return true;
// }
// allInvolvedFields.Reverse();
TypeEx prevFieldType = null;
for (int count = 0; count < allInvolvedFields.Count; count++)
{
var currentField = allInvolvedFields[count];
// if (count + 1 < allInvolvedFields.Count)
// {
// prevFieldType = allInvolvedFields[count + 1].Type;
// }
if (!MethodOrFieldAnalyzer.TryGetDeclaringTypeDefinition(host, currentField, out declaringType))
{
host.Log.LogError(WikiTopics.MissingWikiTopic, "targetfield",
"Failed to get the declaring type for the field " + currentField.FullName);
ErrorLog.AppendLine("Failed to get the declaring type for the field " + currentField.FullName);
targetType = null;
return false;
}
try
{
SafeDebug.Assume(
prevFieldType == null || prevFieldType == declaringType ||
prevFieldType.IsAssignableTo(declaringType)
|| declaringType.IsAssignableTo(prevFieldType),
"The current field type (" + declaringType + ") should be the same as the previous field type (" +
prevFieldType + ")");
if (MethodOrFieldAnalyzer.IsFieldExternallyVisible(host, declaringType, currentField))
{
prevFieldType = currentField.Type;
continue;
}
}
catch (Exception ex)
{
ErrorLog.AppendLine("Failed to compute external visibility of field " + currentField.FullName + " because of " + ex);
}
targetField = currentField;
targetType = declaringType;
return true;
}
targetField = allInvolvedFields[allInvolvedFields.Count - 1];
if (!MethodOrFieldAnalyzer.TryGetDeclaringTypeDefinition(host, targetField, out declaringType))
{
host.Log.LogError(WikiTopics.MissingWikiTopic, "targetfield",
"Failed to get the declaring type for the field " + targetField.FullName);
targetType = null;
return false;
}
targetType = targetField.Type;
return true;
}
private void processArrayResult(PexTrackingFrame frame, Field f, TypeEx type, Term initialElementValue, Term fieldValue, Term initialValue)
{
//below handles array-type fields
if (type.Spec == TypeSpec.SzArray &&//is array
!this.TermManager.IsDefaultValue(fieldValue))//is not null pointer
{
Term index = this.TermManager.Symbol(SzArrayIndexId.Instance);
Term elementValue = frame.Thread.State.ReadSzArrayElement(type.ElementType.Layout, fieldValue, index);
if (elementValue != initialElementValue)
this.explorationObserver.HandleMonitoredField(
frame.Method,
f,
new Term[] { index },
this.TermManager.Widen(elementValue, type.ElementType.StackWidening),
initialValue); //some complicated trick, no need to know
}
}
/// <summary>
/// Accepts a type and returns the persistent string form "assemblyname#typename" of the type.
/// </summary>
/// <param name="method"></param>
/// <returns></returns>
public static string GetPersistentStringFormOfTypeEx(TypeEx type)
{
var assemblyname = type.Definition.Module.Assembly.Location;
return assemblyname + PexMeConstants.PexMePersistenceFormSeparator + type.FullName;
}
/// <inheritdoc/>
public override bool IsFixtureIgnored(TestFrameworkTestSelection testSelection, TypeEx fixtureType, out string ignoreMessage)
{
// xUnit.net does not support skipping test classes
ignoreMessage = null;
return false;
}
/// <summary>
/// Computes method effects statically. All written fields of a method.
/// Can be imprecise and conservative
/// </summary>
/// <param name="declaringType"></param>
/// <param name="method"></param>
/// <param name="effects"></param>
/// <returns></returns>
public static bool TryComputeMethodEffects(IPexComponent host, TypeEx declaringType, Method method,
SafeSet<Method> visitedMethods, out MethodEffects effects)
{
SafeDebug.AssumeNotNull(declaringType, "declaringType");
SafeDebug.AssumeNotNull(method, "method");
try
{
if (visitedMethods == null)
visitedMethods = new SafeSet<Method>();
if (visitedMethods.Contains(method))
{
effects = null;
return false;
}
visitedMethods.Add(method);
//Check whether this has been computed before
var psd = host.GetService<IPexMeStaticDatabase>() as PexMeStaticDatabase;
if (psd.MethodEffectsDic.TryGetValue(method.GlobalIndex, out effects))
return true;
var res = new SafeSet<string>();
var directSetFields = new SafeSet<string>();
var directCalledMethods = new SafeSet<Method>();
var returnFields = new SafeSet<Field>();
var modificationTypeDic = new SafeDictionary<string, FieldModificationType>();
var parameters = method.Parameters;
MethodBodyEx body;
if (!method.TryGetBody(out body) || !body.HasInstructions)
{
effects = null;
return false;
}
int callDepth = 0;
int offset = 0;
Instruction instruction;
OpCode prevOpcode = OpCodes.Nop;
//Stack for load instructions
Field lastAccessedArrayField = null;
Field lastAccessedField = null;
while (body.TryGetInstruction(offset, out instruction))
{
SafeDebug.AssumeNotNull(instruction, "instruction");
OpCode opCode = instruction.OpCode;
if (LdcOpCodes.Contains(opCode))
{
//topIsConstant = true;
}
else if (ConvOpCodes.Contains(opCode))
{
// do not change topIsConstant
}
else
{
if (opCode == OpCodes.Stfld)
{
SafeDebug.Assume(opCode.OperandType == OperandType.InlineField, "opCode.OperandType == OperandType.InlineField");
Field field = instruction.Field;
AddFieldToMethodEffects(host, declaringType, res, directSetFields, modificationTypeDic, prevOpcode, field, field.Type);
}
else if (opCode == OpCodes.Ldfld || opCode == OpCodes.Ldflda)
{
SafeDebug.Assume(opCode.OperandType == OperandType.InlineField, "opCode.OperandType == OperandType.InlineField");
Field accessedField = instruction.Field;
if (accessedField.Type.Spec == TypeSpec.SzArray)
{
lastAccessedArrayField = accessedField;
}
else
lastAccessedField = accessedField;
}
else if (StElemOpCodes.Contains(opCode))
{
if (lastAccessedArrayField != null)
{
//Indicates that there is n array type modified
AddFieldToMethodEffects(host, declaringType, res, directSetFields, modificationTypeDic, prevOpcode, lastAccessedArrayField, lastAccessedArrayField.Type);
lastAccessedArrayField = null;
}
}
else if (opCode == OpCodes.Call || opCode == OpCodes.Callvirt)
{
SafeDebug.Assume(opCode.OperandType == OperandType.InlineMethod, "opCode.OperandType == OperandType.InlineMethod");
Method methodinner = instruction.Method;
SafeDebug.AssumeNotNull(method, "method");
directCalledMethods.Add(methodinner);
TypeEx methodDeclaringType;
//are these function calls are within the parent types
if (methodinner.TryGetDeclaringType(out methodDeclaringType) &&
declaringType.IsAssignableTo(methodDeclaringType))
{
MethodEffects methodEffects;
if (TryComputeMethodEffects(host, methodDeclaringType, methodinner, visitedMethods, out methodEffects))
{
res.AddRange(methodEffects.WrittenInstanceFields);
foreach (var key in methodEffects.ModificationTypeDictionary.Keys)
modificationTypeDic[key] = methodEffects.ModificationTypeDictionary[key];
directSetFields.AddRange(methodEffects.DirectSetterFields);
if (methodEffects.CallDepth > callDepth)
callDepth = methodEffects.CallDepth;
}
}
else
{
//introducing heuristics for inter-procedural static analysis
if (lastAccessedField != null && lastAccessedField.Type.IsReferenceType &&
!(methodinner.ShortName.StartsWith("Get") || methodinner.ShortName.StartsWith("get")
|| methodinner.ShortName.StartsWith("Set") || methodinner.ShortName.StartsWith("set")))
{
AddFieldToMethodEffects(host, declaringType, res, directSetFields, modificationTypeDic,
prevOpcode, lastAccessedField, lastAccessedField.Type);
}
}
}
else if (opCode == OpCodes.Ret)
{
if (instruction.Field != null)
returnFields.Add(instruction.Field);
}
//topIsConstant = false;
}
prevOpcode = opCode;
offset = instruction.NextOffset;
}
effects = new MethodEffects((IFiniteSet<string>)res, directSetFields, directCalledMethods, returnFields, modificationTypeDic, callDepth + 1);
psd.MethodEffectsDic[method.GlobalIndex] = effects;
return true;
}
catch (Exception ex)
{
host.Log.LogErrorFromException(ex, WikiTopics.MissingWikiTopic, "methodeffects",
"Failed to compute method effects for method " + method.FullName + "," + ex.Message);
effects = null;
return false;
}
}
/// <inheritdoc/>
public override bool TryGetFixtureSetupTeardownMethods(TypeEx type, out Method fixtureSetup, out Method fixtureTeardown, out Method testSetup, out Method testTeardown)
{
// Constructor and Dispose are supported natively
testSetup = testTeardown = fixtureSetup = fixtureTeardown = null;
return false;
}
public static TypeEx AddFieldToMethodEffects(IPexComponent host, TypeEx declaringType, SafeSet<string> res,
SafeSet<string> directSetFields, SafeDictionary<string, FieldModificationType> modificationTypeDic,
OpCode prevOpcode, Field field, TypeEx fieldType)
{
SafeDebug.AssumeNotNull(field, "field");
SafeDebug.Assume(!field.IsStatic, "!field.IsStatic");
TypeEx fieldDeclaringType;
//The following check ensures that the field belongs to this class
//or its base classes
if (field.TryGetDeclaringType(out fieldDeclaringType) &&
declaringType.IsAssignableTo(fieldDeclaringType))
{
res.Add(field.ShortName);
FieldModificationType fmt = FieldModificationType.UNKNOWN;
if (fieldType == SystemTypes.Int32 || fieldType == SystemTypes.Int64 || fieldType == SystemTypes.Int16)
{
if (prevOpcode == OpCodes.Add)
fmt = FieldModificationType.INCREMENT;
else if (prevOpcode == OpCodes.Sub)
fmt = FieldModificationType.DECREMENT;
else if (prevOpcode == OpCodes.Call || prevOpcode == OpCodes.Calli || prevOpcode == OpCodes.Callvirt)
fmt = FieldModificationType.METHOD_CALL;
else
host.Log.LogWarning(WikiTopics.MissingWikiTopic, "fieldmodificationtype",
"Encountered unknown modification type for integer type " + prevOpcode);
}
else
{
if (field.Type.IsReferenceType)
{
if (prevOpcode == OpCodes.Ldnull)
fmt = FieldModificationType.NULL_SET;
else if (prevOpcode == OpCodes.Newarr || prevOpcode == OpCodes.Newobj)
fmt = FieldModificationType.NON_NULL_SET;
else if (LdArgOpCodes.Contains(prevOpcode))
fmt = FieldModificationType.NON_NULL_SET;
else
{
fmt = FieldModificationType.METHOD_CALL; //A method call is invoked on this field, which updates this field
}
}
else if (fieldType == SystemTypes.Bool)
{
if (prevOpcode == OpCodes.Ldc_I4_0)
fmt = FieldModificationType.FALSE_SET;
else if (prevOpcode == OpCodes.Ldc_I4_1)
fmt = FieldModificationType.TRUE_SET;
else
host.Log.LogWarning(WikiTopics.MissingWikiTopic, "fieldmodificationtype",
"Encountered unknown modification type for boolean type " + prevOpcode);
}
}
//Store the value of fmt. Sometimes, the same field
//can be modified in different ways within the method, for example
//setting a boolean field to both true or false. In that case, the modification
//type is left as unknown
FieldModificationType prevFMT;
if (modificationTypeDic.TryGetValue(field.ShortName, out prevFMT))
{
//There is some entry for this field
if (prevFMT != FieldModificationType.UNKNOWN && prevFMT != fmt)
{
modificationTypeDic[field.ShortName] = FieldModificationType.UNKNOWN;
}
}
else
{
modificationTypeDic[field.ShortName] = fmt;
}
//A heuristic based approach for aliasing analysis for checking whether the field is directly
//assigned any parameters
if (LdArgOpCodes.Contains(prevOpcode))
directSetFields.Add(field.ShortName);
}
return fieldDeclaringType;
}
/// <inheritdoc/>
public override bool TryReadExpectedException(ICustomAttributeProviderEx target, out TypeEx exceptionType)
{
// xUnit.net does not have an [ExpectedException] attribute
exceptionType = null;
return false;
}
/// <summary>
/// Tries to get a property that returns a given field. Needs to go base classes
/// also
/// </summary>
/// <param name="host"></param>
/// <param name="type"></param>
/// <param name="field"></param>
/// <param name="property"></param>
/// <returns></returns>
public static bool TryGetPropertyReadingField(IPexComponent host, TypeEx type, Field field, out Property property)
{
if (type == null)
{
property = null;
return false;
}
if (type.DeclaredProperties != null)
{
foreach (Property prop in type.DeclaredProperties)
{
Method getter = prop.Getter;
if (getter == null)
continue;
MethodEffects me;
if (TryComputeMethodEffects(host, type, getter, null, out me) && me.ReturnFields.Contains(field))
{
property = prop;
return true;
}
}
}
var baseType = type.BaseType;
if (baseType != null)
{
if (TryGetPropertyReadingField(host, baseType, field, out property))
return true;
}
property = null;
return false;
}
public DeclClassEntity(TypeEx td)
{
this.td = td;
this.host = DUCoverStore.GetInstance().Host;
}
public static bool TryGetTypeExFromName(IPexComponent host, AssemblyEx assembly, string typename, out TypeEx typeEx)
{
if(typeExCache.TryGetValue(typename, out typeEx))
return true;
typeEx = null;
foreach (var assemtype in assembly.TypeDefinitions)
{
if (assemtype.FullName == typename)
{
typeEx = assemtype.Instantiate(GetGenericTypeParameters(host, assemtype));
typeExCache.Add(typename, typeEx);
return true;
}
}
return false;
}
/// <summary>
/// Tries the read expected exception.
/// </summary>
/// <param name="target">
/// The method.
/// </param>
/// <param name="exceptionType">
/// Type of the exception.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public override bool TryReadExpectedException(ICustomAttributeProviderEx target, out TypeEx exceptionType)
{
var attribute = AttributeHelper.GetAttribute(target, ExpectedExceptionAttribute);
if (attribute != null)
{
var attributeType = attribute.GetType();
// read exception type using reflection.
var field = attributeType.GetField("expectedException", BindingFlags.NonPublic | BindingFlags.Instance);
if (field != null)
{
var t = field.GetValue(attribute) as Type;
bool isClass;
if (t != null && ReflectionHelper.TryGetIsClass(t, out isClass) && isClass
&& !ReflectionHelper.ContainsGenericParameters(t))
{
exceptionType = MetadataFromReflection.GetType(t);
return true;
}
}
}
exceptionType = null;
return false;
}
public override int GetNextCallId(int threadId, int offset, IMethodSignature methodSignature, TypeEx[] varArgTypes, Term[] arguments)
{
DumpInfo(methodSignature, threadId, offset, varArgTypes);
var termManager = host.ExplorationServices.TermManager;
var method = methodSignature as Method;
if (method != null)
{
Dump("method name: " + method.FullName + " offset: " + offset);
if (!method.FullName.Equals(_trackMethod.FullName))
{
Dump("method: " + method.FullName + " is not tracking method " + _trackMethod);
Dump("end GetNextCallId=============================");
Dump("");
return 0;
}
}
if (method != null)
{
Dump("method name: " + method.FullName);
if (method.FullName.Equals(_trackMethod.FullName))
{
bool foundSymbol = false;
if (arguments == null)
{
Dump("args is null");
}
else
{
string arg = "";
foreach (Term term in arguments)
{
arg += "arg: " + term + " is symbolic: " + termManager.IsSymbol(term);
var extractor = new ResultTrackConditionExtractor(termManager);
extractor.VisitTerm(default(TVoid), term);
arg += " symbol: " + extractor.Log;
}
Dump("args: " + arg);
foreach (Term argument in arguments)
{
if (termManager.IsSymbol(argument))
{
foundSymbol = true;
break;
}
}
}
track = foundSymbol;
if (track)
{
Dump("track " + method.FullName);
trackArg = true;
methodForTrackingArg = method;
Dump("track parameter of " + method.FullName);
}
}
}
else
{
Dump(methodSignature + " signature is null.");
}
Dump("end GetNextCallId=============================");
Dump("");
return 0;
}
/// <summary>
/// Gets the type definition of a field
/// </summary>
/// <param name="host"></param>
/// <param name="field"></param>
/// <param name="ftex"></param>
/// <returns></returns>
public static bool TryGetDeclaringTypeDefinition(IPexComponent host, Field field, out TypeEx ftex)
{
var fdefinition = field.Definition;
TypeDefinition td;
if (!fdefinition.TryGetDeclaringType(out td))
{
host.Log.LogError(WikiTopics.MissingWikiTopic, "fieldanalyzer",
"Failed to retrieve the declaring type of the field " + field.FullName);
ftex = null;
return false;
}
try
{
ftex = td.Instantiate(new TypeEx[0]);
}
catch (ArgumentException argEx)
{
ftex = td.Instantiate(new TypeEx[] {MetadataFromReflection.GetType(typeof(object))});
}
catch (Exception ex)
{
ftex = null;
Log.AppendLine("Instantiate typeEx fail: " + ex);
}
return true;
}
private void DumpInfo(IMethodSignature methodSignature, int threadId, int offset, TypeEx[] varArgTypes)
{
Dump("in GetNextCallId=============================");
Dump("method of the stack: " + methodStack.Peek().FullName);
try
{
Dump("threadId: " + threadId + " offset: " + offset + " method: " + methodSignature);
if (varArgTypes == null)
{
Dump("types is null");
}
else
{
string types = "";
foreach (TypeEx ex in varArgTypes)
{
types += "varArgType: " + ex + ", ";
}
Dump("types: " + types);
}
}
catch (Exception e)
{
Dump(e.Message + " trace: " +e.StackTrace);
}
}
/// <summary>
/// Tries to get a property that modifies the given field
/// </summary>
/// <param name="host"></param>
/// <param name="type"></param>
/// <param name="field"></param>
/// <param name="property"></param>
/// <returns></returns>
public static bool TryGetPropertyModifyingField(IPexComponent host, TypeEx type, Field field,
out Property property)
{
foreach (Property prop in type.DeclaredProperties)
{
Method setter = prop.Setter;
if (setter == null)
continue;
MethodEffects me;
if (TryComputeMethodEffects(host, type, setter, null, out me) &&
me.WrittenInstanceFields.Contains(field))
{
property = prop;
return true;
}
}
var baseType = type.BaseType;
if (baseType != null)
{
TryGetPropertyModifyingField(host, baseType, field, out property);
}
property = null;
return false;
}