public virtual void HandleViolation(ISymbolTable context, IProblemPipe problemPipe) { if (_problemMetadata != null) { problemPipe.AddProblem (_problemMetadata); } }
public void Build_ReturnsAllStatementHandlersNeededByBlockParser() { MockRepository mocks = new MockRepository(); IBlacklistManager blacklistManager = mocks.Stub <IBlacklistManager>(); IProblemPipe problemPipe = mocks.Stub <IProblemPipe>(); BlockParserContext blockParserContext = new BlockParserContext( problemPipe, Fragment.CreateNamed("returnFragmentType"), new List <ReturnCondition>(), blacklistManager, delegate { }); StatementHandlerDictionaryBuilder builder = new StatementHandlerDictionaryBuilder(blockParserContext); Dictionary <Type, IStatementHandler> handlers = builder.Build(); bool assignmentStatementSupported = handlers.ContainsKey(typeof(AssignmentStatement)); bool branchSupported = handlers.ContainsKey(typeof(Branch)); bool expressionStatementSupported = handlers.ContainsKey(typeof(ExpressionStatement)); bool returnNodeSupported = handlers.ContainsKey(typeof(ReturnNode)); bool switchInstructionSupported = handlers.ContainsKey(typeof(SwitchInstruction)); bool necessaryHandlersSupported = assignmentStatementSupported && branchSupported && expressionStatementSupported && returnNodeSupported && switchInstructionSupported; bool correctHandlerCount = handlers.Keys.Count == 5; Assert.That(necessaryHandlersSupported && correctHandlerCount, Is.True); }
private void HandleFragmentConflict(ISymbolTable context, IProblemPipe problemPipe) { if (ProblemMetadata != null) problemPipe.AddProblem (_problemMetadata); context.MakeUnsafe (_symbol); }
public virtual void HandleViolation(ISymbolTable context, IProblemPipe problemPipe) { if (_problemMetadata != null) { problemPipe.AddProblem(_problemMetadata); } }
public MethodGraphBuilder(Method method, IBlacklistManager blacklistManager, IProblemPipe problemPipe, Fragment returnFragment) : this(method, blacklistManager, problemPipe) { ArgumentUtility.CheckNotNull("returnFragment", returnFragment); _returnFragment = returnFragment; }
public BlockParserContext(IProblemPipe problemPipe, Fragment returnFragmentType, List <ReturnCondition> returnConditions, IBlacklistManager blacklistManager, BlockParser.InspectCallback inspect) { _problemPipe = problemPipe; _returnFragmentType = returnFragmentType; _returnConditions = returnConditions; _blacklistManager = blacklistManager; _inspect = inspect; }
public BlockParserContext(IProblemPipe problemPipe, Fragment returnFragmentType, List<ReturnCondition> returnConditions, IBlacklistManager blacklistManager, BlockParser.InspectCallback inspect) { _problemPipe = problemPipe; _returnFragmentType = returnFragmentType; _returnConditions = returnConditions; _blacklistManager = blacklistManager; _inspect = inspect; }
private void HandleFragmentConflict(ISymbolTable context, IProblemPipe problemPipe) { if (ProblemMetadata != null) { problemPipe.AddProblem(_problemMetadata); } context.MakeUnsafe(_symbol); }
public BlockParser( IBlacklistManager blacklistManager, IProblemPipe problemPipe, Fragment returnFragmentType, List<ReturnCondition> returnConditions) { _blacklistManager = ArgumentUtility.CheckNotNull ("blacklistManager", blacklistManager); _problemPipe = ArgumentUtility.CheckNotNull ("typeParser", problemPipe); _returnFragmentType = returnFragmentType; _returnConditions = returnConditions; BlockParserContext blockParserContext = new BlockParserContext ( _problemPipe, _returnFragmentType, _returnConditions, _blacklistManager, Inspect ); StatementHandlerDictionaryBuilder handlerBuilder = new StatementHandlerDictionaryBuilder (blockParserContext); _statementHandlers = handlerBuilder.Build(); _methodCallAnalyzer = new MethodCallAnalyzer (_problemPipe); }
public override void HandleViolation(ISymbolTable context, IProblemPipe problemPipe) { if (!IsViolated (context)) return; bool symbolIsUndefined = context.Contains (_symbol) && context.GetFragmentType (_symbol).Undefined; if (symbolIsUndefined) { SetSymbolFragmentType(context); } else { HandleFragmentConflict (context, problemPipe); } }
public void HandleViolation_ProblemMetadataGivenButNoViolation_NoProblemAdded() { var expectedFragment = Fragment.CreateNamed(c_expectedType); var givenFragment = Fragment.CreateNamed(c_expectedType); IPreCondition preCondition = new CustomInferencePreCondition(c_symbol, expectedFragment, _problemMetadata); var context = new SymbolTable(_blacklistManager); context.MakeSafe(c_symbol, givenFragment); IProblemPipe problemPipe = MockRepository.GenerateMock <IProblemPipe>(); preCondition.HandleViolation(context, problemPipe); problemPipe.AssertWasNotCalled(pipe => pipe.AddProblem(Arg <ProblemMetadata> .Is.Anything)); }
public BlockParser( IBlacklistManager blacklistManager, IProblemPipe problemPipe, Fragment returnFragmentType, List <ReturnCondition> returnConditions) { _blacklistManager = ArgumentUtility.CheckNotNull("blacklistManager", blacklistManager); _problemPipe = ArgumentUtility.CheckNotNull("typeParser", problemPipe); _returnFragmentType = returnFragmentType; _returnConditions = returnConditions; BlockParserContext blockParserContext = new BlockParserContext( _problemPipe, _returnFragmentType, _returnConditions, _blacklistManager, Inspect ); StatementHandlerDictionaryBuilder handlerBuilder = new StatementHandlerDictionaryBuilder(blockParserContext); _statementHandlers = handlerBuilder.Build(); _methodCallAnalyzer = new MethodCallAnalyzer(_problemPipe); }
public void HandleViolation_ViolationNotProvoked_KeepsSymbolFragment() { var expectedFragment = Fragment.CreateNamed(c_expectedType); var givenFragment = expectedFragment; IPreCondition preCondition = new CustomInferencePreCondition(c_symbol, expectedFragment, _problemMetadata); var context = new SymbolTable(_blacklistManager); context.MakeSafe(c_symbol, givenFragment); IProblemPipe problemPipe = MockRepository.GenerateMock <IProblemPipe>(); preCondition.HandleViolation(context, problemPipe); bool symbolFragmentKept = context.GetFragmentType(c_symbol) == expectedFragment; Assert.That(symbolFragmentKept, Is.True); }
public override void HandleViolation(ISymbolTable context, IProblemPipe problemPipe) { if (!IsViolated(context)) { return; } bool symbolIsUndefined = context.Contains(_symbol) && context.GetFragmentType(_symbol).Undefined; if (symbolIsUndefined) { SetSymbolFragmentType(context); } else { HandleFragmentConflict(context, problemPipe); } }
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); }
public void PassProblem( MethodCall methodCall, List<IPreCondition> preConditions, ProblemMetadata problemMetadata, ISymbolTable symbolTable, IProblemPipe problemPipe) { Method calleeMethod = IntrospectionUtility.ExtractMethod (methodCall); if(_coveredMethods.Contains(calleeMethod.FullName)) { foreach (var operand in methodCall.Operands) { string nestedVariableName; if (OperandIsVariableFromPrecedingBlock (operand, symbolTable, out nestedVariableName)) { preConditions.Add (new AssignabilityPreCondition (nestedVariableName, problemMetadata.ExpectedFragment, problemMetadata)); } else { problemPipe.AddProblem (problemMetadata); } } } }
public ProblemDuplicateFilter(IProblemPipe problemDestination) { _problemDestination = problemDestination; _filteredIds = new List <int>(); }
public MethodGraphAnalyzer(IProblemPipe problemPipe) { _problemPipe = ArgumentUtility.CheckNotNull("problemPipe", problemPipe); }
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 TypeParser(IBlacklistManager blacklistManager) : base("TypeParser") { _problemFilter = new ProblemDuplicateFilter (this); _blacklistManager = blacklistManager; }
public TypeParser(IBlacklistManager blacklistManager) : base("TypeParser") { _problemFilter = new ProblemDuplicateFilter(this); _blacklistManager = blacklistManager; }
public void SetUp() { _mocks = new MockRepository(); _problemDestination = _mocks.StrictMock <IProblemPipe>(); }
public void SetUp() { _mocks = new MockRepository(); _problemDestination = _mocks.StrictMock<IProblemPipe>(); }
public ProblemDuplicateFilter(IProblemPipe problemDestination) { _problemDestination = problemDestination; _filteredIds = new List<int>(); }
public void PassProblem(MethodCall methodCall, List<IPreCondition> preConditions, ProblemMetadata problemMetadata, ISymbolTable symbolTable, IProblemPipe problemPipe) { throw new NotImplementedException(); }
public void PassProblem( MethodCall methodCall, List <IPreCondition> preConditions, ProblemMetadata problemMetadata, ISymbolTable symbolTable, IProblemPipe problemPipe) { Method calleeMethod = IntrospectionUtility.ExtractMethod(methodCall); if (_coveredMethods.Contains(calleeMethod.FullName)) { foreach (var operand in methodCall.Operands) { string nestedVariableName; if (OperandIsVariableFromPrecedingBlock(operand, symbolTable, out nestedVariableName)) { preConditions.Add(new AssignabilityPreCondition(nestedVariableName, problemMetadata.ExpectedFragment, problemMetadata)); } else { problemPipe.AddProblem(problemMetadata); } } } }
public MethodCallAnalyzer(IProblemPipe problemPipe) { _problemPipe = problemPipe; _customInferenceController = new CustomInferenceController(); }
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 PassProblem(MethodCall methodCall, List <IPreCondition> preConditions, ProblemMetadata problemMetadata, ISymbolTable symbolTable, IProblemPipe problemPipe) { throw new NotImplementedException(); }
public MethodGraphAnalyzer(IProblemPipe problemPipe) { _problemPipe = ArgumentUtility.CheckNotNull ("problemPipe", problemPipe); }