public void Parse_UnsafeCallOnMethodInheritedFromSuperiorClass_ReturnsProblem() { TypeNode sampleTypeNode = IntrospectionUtility.TypeNodeFactory <InheritanceSampleMethod>(); Microsoft.FxCop.Sdk.Method sample = IntrospectionUtility.MethodFactory(sampleTypeNode, "UnsafeCallOnMethodInheritedFromSuperiorClass"); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.True); }
public void Parse_SafeStaticBindingOnNewMethod_NoProblem() { TypeNode sampleTypeNode = IntrospectionUtility.TypeNodeFactory <InheritanceSampleMethod>(); Microsoft.FxCop.Sdk.Method sample = IntrospectionUtility.MethodFactory(sampleTypeNode, "SafeStaticBindingOnNewMethod"); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.False); }
public void Parse_SafeCallWithInheritedProperty_NoProblem() { TypeNode sampleTypeNode = IntrospectionUtility.TypeNodeFactory <InheritanceSampleProperty>(); Method sample = IntrospectionUtility.MethodFactory(sampleTypeNode, "SafeCallWithInheritedProperty"); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.False); }
public void Parse_UnsafeDynamicBinding_ReturnsProblem() { TypeNode sampleTypeNode = IntrospectionUtility.TypeNodeFactory <InheritanceSampleMethod>(); Method sample = IntrospectionUtility.MethodFactory(sampleTypeNode, "UnsafeDynamicBinding"); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.True); }
public void Parse_UnsafeAssignmentOnPropertyHidingParent_ReturnsProblem() { TypeNode sampleTypeNode = IntrospectionUtility.TypeNodeFactory <InheritanceSampleProperty>(); Method sample = IntrospectionUtility.MethodFactory(sampleTypeNode, "UnsafeAssignmentOnPropertyHidingParent"); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.False); }
public void Parse_SafeCallOnClassImplementingInterfaceMethodWithFragmentParameter_NoProblem() { TypeNode sampleTypeNode = IntrospectionUtility.TypeNodeFactory <InheritanceSampleInterface>(); Method sample = IntrospectionUtility.MethodFactory(sampleTypeNode, "SafeCallOnClassImplementingInterfaceMethodWithFragmentParameter"); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.False); }
public void Parse_InterfaceReturnFragmentsOfExplicitlyDeclaredMethodAreConsidered_NoProblem() { TypeNode sampleTypeNode = IntrospectionUtility.TypeNodeFactory <InheritanceSampleInterface>(); Method sample = IntrospectionUtility.MethodFactory(sampleTypeNode, "InterfaceReturnFragmentsOfExplicitlyDeclaredMethodAreConsidered"); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.False); }
public void Parse_InvalidReturnWithIfFragmentTypeConsidered_NoProblem() { TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>(); Method sample = TestHelper.GetSample <AssignmentPropagationSample> ("InvalidReturnWithIfFragmentTypeConsidered", stringTypeNode); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.True); }
public void Parse_ValidReturnWithParameterReset_NoProblem() { TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>(); Method sample = TestHelper.GetSample <AssignmentPropagationSample> ("ValidReturnWithParameterReset", stringTypeNode); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.False); }
public void Parse_InvalidReturnOnExplicitInterfaceMethod_ReturnsProblem() { TypeNode sampleTypeNode = IntrospectionUtility.TypeNodeFactory(typeof(InterfaceSampleExplicitDeclarationsInvalidReturn)); Method sample = IntrospectionUtility.MethodFactory(sampleTypeNode, "InjectionCop.IntegrationTests.Parser.TypeParsing.TypeParserTests.Inheritance.Interface.IInheritanceSample.MethodWithReturnFragment"); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.True); }
public void Parse_InvalidReturnOnImplicitExtendedInterfaceMethod_ReturnsProblem() { TypeNode sampleTypeNode = IntrospectionUtility.TypeNodeFactory(typeof(ExtendedInterfaceSampleImplicitDeclarationsInvalidReturn)); Method sample = IntrospectionUtility.MethodFactory(sampleTypeNode, "MethodWithReturnFragment"); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.True); }
public void GetField_NonFieldAssignment_ReturnsNull() { Method sample = TestHelper.GetSample <IntrospectionUtility_ClassSample> ("NonFieldAssignment"); Block assignmentBlock = (Block)sample.Body.Statements[0]; AssignmentStatement assignmentStatement = (AssignmentStatement)assignmentBlock.Statements[1]; Expression sampleExpression = assignmentStatement.Target; Field extractedField = IntrospectionUtility.GetField(sampleExpression); bool extractionCorrect = extractedField == null; Assert.That(extractionCorrect, Is.True); }
public void Parse_UnsafePreCondition() { TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>(); Method sampleMethod = TestHelper.GetSample <BlockParserSample> ("UnsafePreCondition", stringTypeNode); Block sample = sampleMethod.Body.Statements[0] as Block; BasicBlock basicBlock = _blockParser.Parse(sample); bool correctPreCondition = basicBlock.PreConditions[0].Symbol == "unSafe" && basicBlock.PreConditions[0].Fragment == Fragment.CreateNamed("SqlFragment"); Assert.That(correctPreCondition, Is.True); }
public void Parse_RefReturnPreconditionCheckSafeLiteralAssignment_NoProblem() { TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>(); Method sampleMethod = TestHelper.GetSample <BlockParserSample> ("RefReturnPreconditionCheckSafeLiteralAssignment", stringTypeNode.GetReferenceType()); Block sample = sampleMethod.Body.Statements[0] as Block; _blockParser.Parse(sample); bool noProblemsArised = _problemPipeStub.Problems.Count == 0; Assert.That(noProblemsArised, Is.True); }
public void Parse_OutReturnPreconditionCheckUnSafe_ReturnsProblem() { TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>(); Method sampleMethod = TestHelper.GetSample <BlockParserSample> ("OutReturnPreconditionCheckUnSafe", stringTypeNode.GetReferenceType()); Block sample = sampleMethod.Body.Statements[0] as Block; _blockParser.Parse(sample); bool problemFound = _problemPipeStub.Problems.Count != 0; Assert.That(problemFound, Is.True); }
public void Parse_ValidReturnWithIf_ReturnsCorrectReturnFragmentType() { _blockParser = new BlockParser(_blacklist, _problemPipeStub, Fragment.CreateNamed("DummyFragment"), new List <ReturnCondition>()); TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>(); Method sampleMethod = TestHelper.GetSample <BlockParserSample> ("ValidReturnWithLiteralAssignmentInsideIf", stringTypeNode); Block sample = sampleMethod.Body.Statements[3] as Block; BasicBlock returnedBlock = _blockParser.Parse(sample); var preConditionFragmentType = returnedBlock.PreConditions[0].Fragment; Assert.That(preConditionFragmentType, Is.EqualTo(Fragment.CreateNamed("DummyFragment"))); }
public Fragment InferFragmentType(MethodCall methodCall, ISymbolTable context) { Fragment returnFragment = Fragment.CreateEmpty(); Method calleeMethod = IntrospectionUtility.ExtractMethod(methodCall); if (_coveredMethods.Contains(calleeMethod.FullName)) { returnFragment = ParameterFragmentUtility.ParameterFragmentIntersection(methodCall, context); } return(returnFragment); }
public void Check_MatchesParametersCorrectly() { var rule = new OverridingMethodFragmentUsageRule(); var method1 = IntrospectionUtility.MethodFactory <DerivedClassWithInvalidFragmentUsage> ( "MethodWithFragmentOnSecondParameter", IntrospectionUtility.TypeNodeFactory <int>(), IntrospectionUtility.TypeNodeFactory <int>()); var method = method1; var result = rule.Check(method); Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.True); }
public void MethodFactory_MethodWithParametersCorrectCall_ReturnsMethod() { Type sampleType = typeof(IntrospectionUtility_InterfaceSample); TypeNode intTypeNode = IntrospectionUtility.TypeNodeFactory <int>(); string sampleMethodname = "MethodWithParameter"; Method result = IntrospectionUtility.MethodFactory(sampleType, sampleMethodname, intTypeNode); bool correctType = result.DeclaringType.FullName == sampleType.FullName; bool correctMethod = result.Name.Name == sampleMethodname; Assert.That(correctMethod && correctType, Is.True); }
private void AddBlockAssignment(AssignmentStatement assignmentStatement, HandleContext context) { string targetSymbol = IntrospectionUtility.GetVariableName(assignmentStatement.Target); string sourceSymbol = IntrospectionUtility.GetVariableName(assignmentStatement.Source); if (targetSymbol != null && sourceSymbol != null) { BlockAssignment blockAssignment = new BlockAssignment(sourceSymbol, targetSymbol); context.BlockAssignments.Add(blockAssignment); } }
public void IsVariable_Method_IsFalse() { Method sample = TestHelper.GetSample <IntrospectionUtility_ClassSample>("UsingField"); Block expressionBlock = (Block)sample.Body.Statements[0]; ExpressionStatement expressionStatement = (ExpressionStatement)expressionBlock.Statements[1]; UnaryExpression sampleUnaryExpression = (UnaryExpression)expressionStatement.Expression; MethodCall sampleMethodCall = (MethodCall)sampleUnaryExpression.Operand; bool methodIsVariable = IntrospectionUtility.IsVariable(sampleMethodCall); Assert.That(methodIsVariable, Is.False); }
public void Parse_UnsafeAssignmentInsideIfNested_ReturnsProblem() { TypeNode intTypeNode = IntrospectionUtility.TypeNodeFactory <int>(); Method sample = TestHelper.GetSample <IfSample>("UnsafeAssignmentInsideIfNested", intTypeNode, intTypeNode, intTypeNode); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.True); }
public void PassProblem( MethodCall methodCall, List <IPreCondition> preConditions, ProblemMetadata problemMetadata, ISymbolTable symbolTable, IProblemPipe problemPipe) { Method calleeMethod = IntrospectionUtility.ExtractMethod(methodCall); ICustomInference matchingRule = MatchingAnalyzeRule(calleeMethod); if (matchingRule != null) { matchingRule.PassProblem(methodCall, preConditions, problemMetadata, symbolTable, problemPipe); } }
public void InferFragmentType_AssignmentWithParameterNonFragment_ReturnsNoFragmentType() { TypeNode intTypeNode = IntrospectionUtility.TypeNodeFactory <int>(); Method sample = TestHelper.GetSample <InferFragmentSample>("AssignmentWithParameter", intTypeNode); Block assignmentBlock = (Block)sample.Body.Statements[0]; AssignmentStatement assignment = (AssignmentStatement)assignmentBlock.Statements[1]; Expression sampleExpression = assignment.Source; var fragmentType = _symbolTable.InferFragmentType(sampleExpression); Assert.That(fragmentType, Is.EqualTo(EmptyFragment)); }
public void Parse_ValidExampleInsideIf_NoProblem() { TypeNode intTypeNode = IntrospectionUtility.TypeNodeFactory <int>(); Method sample = TestHelper.GetSample <IfSample>("ValidExampleInsideIf", intTypeNode, intTypeNode); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.False); }
public void Parse_ConstructorChainingWithBaseClassConstructorWithoutFragment_NoProblem() { TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>(); TypeNode sampleTypeNode = IntrospectionUtility.TypeNodeFactory <InheritanceSampleConstructor>(); Method sample = IntrospectionUtility.MethodFactory(sampleTypeNode, ".ctor", stringTypeNode, stringTypeNode); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.False); }
public void GetVariableName_Method_IsNull() { Method sample = TestHelper.GetSample <IntrospectionUtility_ClassSample>("UsingField"); Block expressionBlock = (Block)sample.Body.Statements[0]; ExpressionStatement expressionStatement = (ExpressionStatement)expressionBlock.Statements[1]; UnaryExpression sampleUnaryExpression = (UnaryExpression)expressionStatement.Expression; MethodCall sampleMethodCall = (MethodCall)sampleUnaryExpression.Operand; string variableName = IntrospectionUtility.GetVariableName(sampleMethodCall); Assert.That(variableName, Is.Null); }
public void InferFragmentType_AssignmentWithParameterFragmentSetToTrue_InfersFragmentType() { _symbolTable.MakeSafe("parameter", Fragment.CreateNamed("DummyType")); TypeNode intTypeNode = IntrospectionUtility.TypeNodeFactory <int>(); Method sample = TestHelper.GetSample <InferFragmentSample>("AssignmentWithParameter", intTypeNode); Block assignmentBlock = (Block)sample.Body.Statements[0]; AssignmentStatement assignment = (AssignmentStatement)assignmentBlock.Statements[1]; Expression sampleExpression = assignment.Source; var fragmentType = _symbolTable.InferFragmentType(sampleExpression); Assert.That(fragmentType, Is.EqualTo(Fragment.CreateNamed("DummyType"))); }
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); } } }
public void GetVariableName_FieldInMemberbinding_ReturnsName() { Method sample = TestHelper.GetSample <IntrospectionUtility_ClassSample>("UsingField"); Block expressionBlock = (Block)sample.Body.Statements[0]; ExpressionStatement expressionStatement = (ExpressionStatement)expressionBlock.Statements[1]; UnaryExpression sampleUnaryExpression = (UnaryExpression)expressionStatement.Expression; MethodCall sampleMethodCall = (MethodCall)sampleUnaryExpression.Operand; Expression sampleExpression = sampleMethodCall.Operands[0]; string variableName = IntrospectionUtility.GetVariableName(sampleExpression); Assert.That(variableName, Is.EqualTo("_field")); }