public void ReturnFragmentType_MethodWithAnnotatedReturn_ReturnsNull()
{
Method sample = TestHelper.GetSample <FragmentUtilitySample> ("ReturnFragment");
var returnFragment = FragmentUtility.ReturnFragmentType(sample);
Assert.That(returnFragment, Is.EqualTo(Fragment.CreateNamed("ReturnFragmentType")));
}
public void ReturnFragmentType_ExplicitlyImplementedInterfaceMethod_ReturnsFragment()
{
Method sample = TestHelper.GetSample <ClassWithExplicitlyDeclaredMethodReturningFragment> ("InjectionCop.IntegrationTests.Utilities.InterfaceWithReturnFragment.MethodWithReturnFragment");
var returnFragment = FragmentUtility.ReturnFragmentType(sample);
Assert.That(returnFragment, Is.EqualTo(Fragment.CreateNamed("ReturnFragmentType")));
}
public void ReturnFragmentType_ImplementedInterfaceMethod_ReturnsFragment()
{
Method sample = TestHelper.GetSample <ClassWithMethodReturningFragment> ("MethodWithReturnFragment");
var returnFragment = FragmentUtility.ReturnFragmentType(sample);
Assert.That(returnFragment, Is.EqualTo(Fragment.CreateNamed("ReturnFragmentType")));
}
public bool IsAssignableTo(string symbolName, Fragment fragmentType)
{
ArgumentUtility.CheckNotNull("symbolName", symbolName);
ArgumentUtility.CheckNotNull("fragmentType", fragmentType);
return(FragmentUtility.FragmentTypesAssignable(GetFragmentType(symbolName), fragmentType));
}
public void ReturnFragmentType_NonAnnotatedMethod_ReturnsEmptyFragment()
{
Method sample = TestHelper.GetSample <FragmentUtilitySample> ("NoReturnFragment");
var returnFragment = FragmentUtility.ReturnFragmentType(sample);
Assert.That(returnFragment, Is.EqualTo(Fragment.CreateEmpty()));
}
public void ContainsFragment_ContainsStronglyTypedSqlFragmentParameter_True()
{
TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>();
Method sample = TestHelper.GetSample <FragmentUtilitySample>("ContainsStronglyTypedSqlFragmentParameter", stringTypeNode);
bool isResult = FragmentUtility.ContainsFragment(sample.Parameters[0].Attributes);
Assert.That(isResult, Is.True);
}
public void GetFragmentType_ContainsStronglyTypedSqlFragmentParameter_True()
{
TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>();
Method sample = TestHelper.GetSample <FragmentUtilitySample>("ContainsStronglyTypedSqlFragmentParameter", stringTypeNode);
var fragmentType = FragmentUtility.GetFragmentType(sample.Parameters[0].Attributes);
Assert.That(fragmentType, Is.EqualTo(Fragment.CreateNamed("SqlFragment")));
}
public void GetFragmentType_ContainsNonFragmentParameter_ThrowsException()
{
TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>();
Method sample = TestHelper.GetSample <FragmentUtilitySample>("ContainsNonFragmentParameter", stringTypeNode);
var returnedFragment = FragmentUtility.GetFragmentType(sample.Parameters[0].Attributes);
Assert.That(returnedFragment, Is.EqualTo(Fragment.CreateEmpty()));
}
public void IsFragment_ContainsNonFragmentParameter_False()
{
TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>();
Method sample = TestHelper.GetSample <FragmentUtilitySample>("ContainsNonFragmentParameter", stringTypeNode);
bool isResult = FragmentUtility.IsFragment(sample.Parameters[0].Attributes[0]);
Assert.That(isResult, Is.False);
}
private void CheckParameter(Expression operand, Fragment expectedFragment)
{
Fragment operandFragmentType = _symbolTable.InferFragmentType(operand);
if (!FragmentUtility.FragmentTypesAssignable(operandFragmentType, expectedFragment))
{
ProblemMetadata problemMetadata = new ProblemMetadata(operand.UniqueKey, operand.SourceContext, expectedFragment, operandFragmentType);
PassProblem(operand, problemMetadata);
}
}
private void AnalyzeFields()
{
IEnumerable <Field> fields = IntrospectionUtility.FilterFields(_method.DeclaringType);
foreach (Field field in fields)
{
if (field.Attributes != null && FragmentUtility.ContainsFragment(field.Attributes))
{
_result.MakeUnsafe(field.Name.Name);
}
}
}
private ISymbolTable GetDelegatesEnvironment(DelegateNode sourceDelegateType)
{
ISymbolTable environment = new SymbolTable(_blockParserContext.BlacklistManager);
foreach (Parameter parameter in sourceDelegateType.Parameters)
{
if (parameter.Attributes != null)
{
environment.MakeSafe(parameter.Name.Name, FragmentUtility.GetFragmentType(parameter.Attributes));
}
}
return(environment);
}
private void HandleVoidReturn(ReturnNode returnNode, HandleContext context)
{
foreach (var returnCondition in _blockParserContext.ReturnConditions)
{
Fragment blockInternalFragmentType = context.SymbolTable.GetFragmentType(returnCondition.Symbol);
if (!FragmentUtility.FragmentTypesAssignable(blockInternalFragmentType, returnCondition.Fragment))
{
ProcessBlockInternalPreConditionViolation(
returnNode, returnCondition, blockInternalFragmentType, context);
}
}
}
private void PassReturnFragmentTypeToContext(Expression operand, Parameter parameter)
{
string symbol = IntrospectionUtility.GetVariableName(operand);
Fragment fragmentType = FragmentUtility.GetFragmentType(parameter.Attributes);
if (FragmentUtility.ContainsFragment(parameter.Attributes))
{
_symbolTable.MakeSafe(symbol, fragmentType);
}
else
{
_symbolTable.MakeUnsafe(symbol);
}
}
private Fragment GetDelegateTypesReturnFragment(DelegateNode sourceDelegateType)
{
var returnFragment = Fragment.CreateEmpty();
foreach (Member member in sourceDelegateType.Members)
{
if (member.Name.Name == "Invoke")
{
Method invoke = (Method)member;
returnFragment = FragmentUtility.ReturnFragmentType(invoke);
}
}
return(returnFragment);
}
private void SetSymbolFragmentType(string name, AttributeNodeCollection attributes)
{
if (!_result.Contains(name))
{
if (FragmentUtility.ContainsFragment(attributes))
{
Fragment fragmentType = FragmentUtility.GetFragmentType(attributes);
_result.MakeSafe(name, fragmentType);
}
else
{
_result.MakeUnsafe(name);
}
}
}
private Fragment InferMethodCallReturnFragmentType(MethodCall methodCall)
{
Fragment returnFragment;
Method calleeMethod = IntrospectionUtility.ExtractMethod(methodCall);
if (_customInferenceController.Infers(calleeMethod))
{
returnFragment = _customInferenceController.InferFragmentType(methodCall, this);
}
else
{
returnFragment = FragmentUtility.InferReturnFragmentType(calleeMethod);
}
return(returnFragment);
}
private void ValidateAssignmentOnField(AssignmentStatement assignmentStatement, HandleContext context)
{
Field targetField = IntrospectionUtility.GetField(assignmentStatement.Target);
Fragment targetFragmentType = FragmentUtility.GetFragmentType(targetField.Attributes);
Fragment givenFragmentType = context.SymbolTable.InferFragmentType(assignmentStatement.Source);
if (!FragmentUtility.FragmentTypesAssignable(givenFragmentType, targetFragmentType))
{
ProblemMetadata problemMetadata = new ProblemMetadata(
targetField.UniqueKey,
targetField.SourceContext,
targetFragmentType,
givenFragmentType);
_blockParserContext.ProblemPipe.AddProblem(problemMetadata);
}
}
private Fragment[] GetParameterFragmentTypes(Method calleeMethod)
{
List <string> parameterTypes = IntrospectionUtility.GetParameterTypes(calleeMethod);
string assemblyName = calleeMethod.ContainingAssembly().Name;
FragmentSignature signature = _blacklistManager.GetFragmentTypes(assemblyName, calleeMethod.DeclaringType.FullName, calleeMethod.Name.Name, parameterTypes);
Fragment[] parameterFragmentTypes;
if (signature == null)
{
parameterFragmentTypes = FragmentUtility.GetAnnotatedParameterFragmentTypes(calleeMethod);
}
else
{
parameterFragmentTypes = signature.ParameterFragmentTypes.Select(name => name != null ? Fragment.CreateNamed(name) : Fragment.CreateEmpty()).ToArray();
}
return(parameterFragmentTypes);
}
protected void MatchFragments(Method baseMethod, Method overridingMethod)
{
foreach (var parameter in baseMethod.Parameters)
{
var fragmentType = FragmentUtility.GetFragmentType(parameter.Attributes);
if (fragmentType != Fragment.CreateEmpty())
{
var overriddenParameter = overridingMethod.Parameters[parameter.ParameterListIndex];
var overriddenFragmentType = FragmentUtility.GetFragmentType(overriddenParameter.Attributes);
if (overriddenFragmentType != fragmentType && overriddenFragmentType != Fragment.CreateEmpty())
{
AddProblem(new ProblemMetadata(overridingMethod.UniqueKey, overridingMethod.SourceContext, fragmentType, overriddenFragmentType));
}
}
}
}
public void Analyze(MethodCall methodCall, ISymbolTable context, List <IPreCondition> preConditions)
{
Method method = IntrospectionUtility.ExtractMethod(methodCall);
if (Analyzes(method) && methodCall.Callee is MemberBinding)
{
MemberBinding memberBinding = (MemberBinding)methodCall.Callee;
if (IsFragmentParameterInferenceMethod(method))
{
string variableName;
if (IntrospectionUtility.IsVariable(memberBinding.TargetObject, out variableName))
{
Fragment parameterFragment = ParameterFragmentUtility.ParameterFragmentIntersection(methodCall, context);
Fragment targetObjectFragment = context.GetFragmentType(variableName);
if (targetObjectFragment == Fragment.CreateLiteral() || targetObjectFragment.Undefined)
{
context.MakeSafe(variableName, parameterFragment);
}
else
{
if (targetObjectFragment == Fragment.CreateEmpty() && parameterFragment != Fragment.CreateLiteral()) // && parameterFragment != Fragment.CreateEmpty()
{
ProblemMetadata problemMetadata = new ProblemMetadata(methodCall.UniqueKey, methodCall.SourceContext, parameterFragment, targetObjectFragment);
IPreCondition precondition = new CustomInferencePreCondition(variableName, parameterFragment, problemMetadata);
preConditions.Add(precondition);
}
else if (!FragmentUtility.FragmentTypesAssignable(parameterFragment, targetObjectFragment))
{
context.MakeUnsafe(variableName);
}
}
}
}
else if (!IsSafeMethod(method))
{
string variableName;
if (IntrospectionUtility.IsVariable(memberBinding.TargetObject, out variableName))
{
context.MakeUnsafe(variableName);
}
}
}
}
public Fragment InferFragmentType(Expression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
var fragmentType = Fragment.CreateEmpty();
if (expression is Literal)
{
fragmentType = Fragment.CreateLiteral();
}
else if (expression is Local)
{
Local local = (Local)expression;
fragmentType = Lookup(local.Name.Name);
}
else if (expression is Parameter)
{
Parameter parameter = (Parameter)expression;
fragmentType = Lookup(parameter.Name.Name);
}
else if (expression is MemberBinding)
{
MemberBinding memberBinding = (MemberBinding)expression;
fragmentType = FragmentUtility.GetMemberBindingFragmentType(memberBinding);
}
else if (expression is MethodCall)
{
MethodCall methodCall = (MethodCall)expression;
fragmentType = InferMethodCallReturnFragmentType(methodCall);
}
else if (expression is UnaryExpression)
{
UnaryExpression unaryExpression = (UnaryExpression)expression;
fragmentType = InferFragmentType(unaryExpression.Operand);
}
else if (expression is Indexer)
{
Indexer indexer = (Indexer)expression;
fragmentType = InferFragmentType(indexer.Object);
}
return(fragmentType);
}
private List <ReturnCondition> ReferenceAndOutConditions(Method method)
{
List <ReturnCondition> referenceAndOutConditions = new List <ReturnCondition>();
foreach (var parameter in method.Parameters)
{
if (parameter.Type is Reference && parameter.Attributes != null)
{
Fragment parameterFragmentType = FragmentUtility.GetFragmentType(parameter.Attributes);
if (parameterFragmentType != null)
{
string parameterName = IntrospectionUtility.GetVariableName(parameter);
ReturnCondition returnCondition = new ReturnCondition(parameterName, parameterFragmentType);
referenceAndOutConditions.Add(returnCondition);
}
}
}
return(referenceAndOutConditions);
}
public MethodGraphBuilder(Method method, IBlacklistManager blacklistManager, IProblemPipe problemPipe)
{
ArgumentUtility.CheckNotNull("method", method);
_blacklistManager = ArgumentUtility.CheckNotNull("blacklistManager", blacklistManager);
_problemPipe = ArgumentUtility.CheckNotNull("problemPipe", problemPipe);
bool isInterfaceMethod = method.Body.Statements == null;
if (!isInterfaceMethod)
{
_methodBody = method.Body;
_referenceAndOutConditions = ReferenceAndOutConditions(method);
_result = null;
}
else
{
_result = new MethodGraph(-1, new Dictionary <int, BasicBlock>());
}
_returnFragment = FragmentUtility.ReturnFragmentType(method);
}
private void AddAssignmentPreCondition(AssignmentStatement assignmentStatement, HandleContext context)
{
Field targetField = IntrospectionUtility.GetField(assignmentStatement.Target);
Fragment targetFragmentType = FragmentUtility.GetFragmentType(targetField.Attributes);
if (targetFragmentType != Fragment.CreateEmpty())
{
ProblemMetadata problemMetadata = new ProblemMetadata(
assignmentStatement.UniqueKey,
assignmentStatement.SourceContext,
targetFragmentType,
Fragment.CreateNamed("??"));
string sourceSymbol = IntrospectionUtility.GetVariableName(assignmentStatement.Source);
if (sourceSymbol != null)
{
AssignabilityPreCondition preCondition = new AssignabilityPreCondition(sourceSymbol, targetFragmentType, problemMetadata);
context.PreConditions.Add(preCondition);
}
}
}
private void CheckMembers(TypeNode type)
{
foreach (Member member in type.Members)
{
if (member is Method)
{
var method = (Method)member;
var fragmentSignature = GetFragmentSignatureFromConfiguration(type, method);
if (!FragmentUtility.IsFragmentGenerator(method) &&
(fragmentSignature == null || !fragmentSignature.IsGenerator))
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
Parse(method);
stopwatch.Stop();
_methodProfilingResults.Add(method.FullName, stopwatch.Elapsed);
}
}
}
}
protected override bool ViolationCheckStrategy(ISymbolTable context)
{
Fragment givenFragment = context.GetFragmentType(_symbol);
return(!FragmentUtility.FragmentTypesAssignable(givenFragment, _fragment));
}
public void IsFragmentGenerator_CustomFragmentGenerator_True()
{
Method sampleMethod = TestHelper.GetSample <FragmentUtilitySample>("CustomFragmentGenerator");
Assert.That(FragmentUtility.IsFragmentGenerator(sampleMethod), Is.True);
}
public void IsFragmentGenerator_ReturnFragment_False()
{
Method sampleMethod = TestHelper.GetSample <FragmentUtilitySample>("ReturnFragment");
Assert.That(FragmentUtility.IsFragmentGenerator(sampleMethod), Is.False);
}
public void NamedFragmentAssignableToUndefinedFragment()
{
FragmentUtility.FragmentTypesAssignable(Fragment.CreateNamed("dummy"), Fragment.CreateUndefined());
}
