private MethodDefinition CreateMethod(string name, Action action, HashSet <IParameterDefinition> parameters) { var method = new MethodDefinition { CallingConvention = CallingConvention.HasThis, InternFactory = host.InternFactory, IsStatic = false, Name = host.NameTable.GetNameFor(name), Type = action.Method.Type, Visibility = TypeMemberVisibility.Public, Parameters = parameters.ToList() }; BlockStatement block = null; // TODO (lleraromero): Por el momento hacemos solo inlining porque sirve para CC / Corral. Realmente deberiamos tener un creador del cuerpo polimorfico //if (Configuration.InlineMethodsBody) //{ block = InlineMethodBody(action); //} //else //{ // block = CallMethod(action); //} method.Body = new SourceMethodBody(host) { MethodDefinition = method, Block = block, LocalsAreZeroed = true }; return(method); }
public IReadOnlyCollection <Transition> AnalyzeTransitions(State source, Action action, IEnumerable <State> targets) { var evaluator = new QueryEvaluator(new CorralMock(), new FileInfo(@"C:\Windows\notepad.exe")); var transitionQueries = CreateTransitionQueries(source, action, targets); return(evaluator.GetFeasibleTransitions(transitionQueries)); }
public IReadOnlyCollection <Transition> AnalyzeTransitions(State source, Action action, IEnumerable <State> targets) { Contract.Requires(source != null); Contract.Requires(action != null); Contract.Requires(targets.Any()); Contract.Ensures(Contract.Result <IReadOnlyCollection <Transition> >().Any()); throw new NotImplementedException(); }
public ActionAnalysisResults AnalyzeActions(State source, Action action, IEnumerable <Action> actions) { Contract.Requires(source != null); Contract.Requires(action != null); Contract.Requires(actions.Any()); Contract.Ensures(Contract.Result <ActionAnalysisResults>() != null); throw new NotImplementedException(); }
private MethodDefinition CreateQueryMethod(State state, string name, Action action, State target) { var parameters = GetStateParameters(state); parameters.UnionWith(action.Method.Parameters); parameters.UnionWith(GetStateParameters(target)); return(CreateMethod(name, action, parameters)); }
private BlockStatement CallMethod(Action action) { throw new NotSupportedException(); //var block = new BlockStatement(); //var args = new List<IExpression>(); //foreach (var arg in action.Parameters) //{ // args.Add(new BoundExpression() // { // Definition = arg, // Instance = null, // Locations = new List<ILocation>(arg.Locations), // Type = arg.Type // }); //} //IMethodReference methodReference = action; //if (typeToAnalyze.IsGeneric) //{ // methodReference = specializedInputType.SpecializeMember(action, host.InternFactory) as IMethodReference; //} //var callExpr = new MethodCall() //{ // Arguments = args, // IsStaticCall = false, // MethodToCall = methodReference, // Type = action.Type, // ThisArgument = new ThisReference(), // Locations = new List<ILocation>(action.Locations) //}; //if (action.Type.TypeCode == PrimitiveTypeCode.Void) //{ // var call = new ExpressionStatement() // { // Expression = callExpr // }; // block.Statements.Add(call); //} //else //{ // var ret = new ReturnStatement() // { // Expression = callExpr // }; // block.Statements.Add(ret); //} //return block; }
protected IReadOnlyCollection <ActionQuery> CreateQueries(State state, Action action, IEnumerable <Action> actions, CciActionQueryGenerator queryGenerator) { var queries = new List <ActionQuery>(); foreach (var actionUnderTest in actions) { queries.Add(queryGenerator.CreateQuery(state, action, actionUnderTest)); } return(queries); }
private Action GenerateQuery(State state, Action action, State target) { var actionName = action.Name; var stateName = state.Name; var targetName = target.Name; var methodName = string.Format("{1}{0}{2}{0}{3}", MethodNameDelimiter, stateName, actionName, targetName); var method = CreateQueryMethod(state, methodName, action, target); var queryContract = CreateQueryContract(state, target); return(new CciAction(method, queryContract)); }
public IReadOnlyCollection <Transition> AnalyzeTransitions(State source, Action action, IEnumerable <State> targets) { ISolver corralRunner = new CorralRunner(defaultArgs, workingDir); var transitionQueries = queryGenerator.CreateTransitionQueries(source, action, targets); var queryAssembly = CreateBoogieQueryAssembly(transitionQueries); var evaluator = new QueryEvaluator(corralRunner, queryAssembly); var feasibleTransitions = evaluator.GetFeasibleTransitions(transitionQueries); unprovenQueriesCount += evaluator.UnprovenQueries; return(feasibleTransitions); }
public IReadOnlyCollection <Transition> AnalyzeTransitions(State source, Action action, IEnumerable <State> targets) { var codeContractsRunner = new CodeContractsRunner(workingDir, ccCheckDefaultArgs, libPaths, typeToAnalyze); var transitionQueries = queryGenerator.CreateTransitionQueries(source, action, targets); var queryAssembly = CreateQueryAssembly(transitionQueries); var evaluator = new QueryEvaluator(codeContractsRunner, queryAssembly); var feasibleTransitions = evaluator.GetFeasibleTransitions(transitionQueries); unprovenQueriesCount += evaluator.UnprovenQueries; return(feasibleTransitions); }
public ActionAnalysisResults AnalyzeActions(State source, Action action, IEnumerable <Action> actions) { var evaluator = new QueryEvaluator(new CorralMock(), new FileInfo(@"C:\Windows\notepad.exe")); var negativeQueries = CreateNegativeQueries(source, action, actions); var disabledActions = new HashSet <Action>(evaluator.GetDisabledActions(negativeQueries)); var positiveQueries = CreatePositiveQueries(source, action, actions); var enabledActions = new HashSet <Action>(evaluator.GetEnabledActions(positiveQueries)); Contract.Assert(!enabledActions.Intersect(disabledActions).Any()); return(new ActionAnalysisResults(enabledActions, disabledActions)); }
public ActionAnalysisResults AnalyzeActions(State source, Action action, IEnumerable <Action> actions) { ISolver corralRunner = new CorralRunner(defaultArgs, workingDir); if (action.IsPure) { return(new ActionAnalysisResults(new HashSet <Action>(source.EnabledActions), new HashSet <Action>(source.DisabledActions))); } var enabledActions = GetMustBeEnabledActions(source, action, actions, corralRunner); var disabledActions = GetMustBeDisabledActions(source, action, actions, corralRunner); Contract.Assert(!enabledActions.Intersect(disabledActions).Any()); return(new ActionAnalysisResults(enabledActions, disabledActions)); }
protected ISet <Action> GetMustBeDisabledActions(State source, Action action, IEnumerable <Action> actions, ISolver corralRunner) { Contract.Requires(source != null); Contract.Requires(action != null); Contract.Requires(actions.Any()); Contract.Requires(corralRunner != null); var targetNegatedPreconditionQueries = queryGenerator.CreateNegativeQueries(source, action, actions); generatedQueriesCount += targetNegatedPreconditionQueries.Count; var queryAssembly = CreateBoogieQueryAssembly(targetNegatedPreconditionQueries); var evaluator = new QueryEvaluator(corralRunner, queryAssembly); var disabledActions = new HashSet <Action>(evaluator.GetDisabledActions(targetNegatedPreconditionQueries)); unprovenQueriesCount += evaluator.UnprovenQueries; return(disabledActions); }
protected ISet <Action> ActionsThatAreAlwaysEnabled(State source, Action action, IEnumerable <Action> actions, CodeContractsRunner codeContractsRunner) { Contract.Requires(source != null); Contract.Requires(action != null); Contract.Requires(actions.Any()); Contract.Requires(codeContractsRunner != null); var targetPreconditionQueries = queryGenerator.CreatePositiveQueries(source, action, actions); generatedQueriesCount += targetPreconditionQueries.Count; var queryAssembly = CreateQueryAssembly(targetPreconditionQueries); var evaluator = new QueryEvaluator(codeContractsRunner, queryAssembly); var enabledActions = new HashSet <Action>(evaluator.GetEnabledActions(targetPreconditionQueries)); unprovenQueriesCount += evaluator.UnprovenQueries; return(enabledActions); }
public ActionAnalysisResults AnalyzeActions(State source, Action action, IEnumerable <Action> actions) { var codeContractsRunner = new CodeContractsRunner(workingDir, ccCheckDefaultArgs, libPaths, typeToAnalyze); if (action.IsPure) { return(new ActionAnalysisResults(new HashSet <Action>(source.EnabledActions), new HashSet <Action>(source.DisabledActions))); } var enabledActions = ActionsThatAreAlwaysEnabled(source, action, actions, codeContractsRunner); var disabledActions = ActionsThatAreAlwaysDisabled(source, action, actions, codeContractsRunner); if (enabledActions.Intersect(disabledActions).Any()) { Logger.Log(LogLevel.Warn, "Suspicious state! Only a state with a unsatisfiable invariant can lead to actions being enabled and disabled at the same time. It can also mean a bug in our code."); return(new ActionAnalysisResults(new HashSet <Action>(source.EnabledActions), new HashSet <Action>(source.DisabledActions))); } return(new ActionAnalysisResults(enabledActions, disabledActions)); }
public IReadOnlyCollection <TransitionQuery> CreateTransitionQueries(State sourceState, Action action, IEnumerable <State> targetStates) { return (targetStates.Select( targetState => new TransitionQuery(GenerateQuery(sourceState, action, targetState), sourceState, action, targetState)).ToList()); }
protected IReadOnlyCollection <ActionQuery> CreateNegativeQueries(State source, Action action, IEnumerable <Action> actions) { var queries = new List <ActionQuery>(); foreach (var a in actions) { var prefix = notPrefix; var actionName = action.Name; var stateName = source.Name; var targetName = a.Name; var methodName = string.Format("{1}{0}{2}{0}{3}{4}", methodNameDelimiter, stateName, actionName, prefix, targetName); var fakeAction = A.Fake <Action>(); A.CallTo(() => fakeAction.Name).Returns(CreateUniqueMethodName(methodName)); var fakeQuery = new ActionQuery(fakeAction, QueryType.Negative, a); queries.Add(fakeQuery); } return(queries); }
protected IReadOnlyCollection <TransitionQuery> CreateTransitionQueries(State source, Action action, IEnumerable <State> targets) { var queries = new List <TransitionQuery>(); foreach (var s in targets) { var actionName = action.Name; var stateName = source.Name; var targetName = s.Name; var methodName = string.Format("{1}{0}{2}{0}{3}", methodNameDelimiter, stateName, actionName, targetName); var fakeAction = A.Fake <Action>(); A.CallTo(() => fakeAction.Name).Returns(CreateUniqueMethodName(methodName)); var fakeQuery = new TransitionQuery(fakeAction, source, action, s); queries.Add(fakeQuery); } return(queries); }
private BlockStatement InlineMethodBody(Action action) { var block = new BlockStatement(); var mc = action.Contract; if (mc != null && mc.Preconditions.Any()) { var asserts = from pre in mc.Preconditions select new AssertStatement { Condition = pre.Condition, OriginalSource = pre.OriginalSource, Description = new CompileTimeConstant { Value = "Inlined method precondition", Type = host.PlatformType.SystemString } }; block.Statements.AddRange(asserts); } IBlockStatement actionBodyBlock = null; if (action.Method.Body is Microsoft.Cci.ILToCodeModel.SourceMethodBody) { var actionBody = action.Method.Body as Microsoft.Cci.ILToCodeModel.SourceMethodBody; actionBodyBlock = actionBody.Block; } else if (action.Method.Body is SourceMethodBody) { var actionBody = action.Method.Body as SourceMethodBody; actionBodyBlock = actionBody.Block; } //Por tratarse de un constructor skipeamos //el primer statement porque es base..ctor(); var skipCount = action.Method.IsConstructor ? 1 : 0; block.Statements.AddRange(actionBodyBlock.Statements.Skip(skipCount)); if (mc != null && mc.Postconditions.Any()) { var assumes = from post in mc.Postconditions select new AssumeStatement { Condition = post.Condition, OriginalSource = post.OriginalSource, Description = new CompileTimeConstant { Value = "Inlined method postcondition", Type = host.PlatformType.SystemString } }; //Ponemos los assume antes del return if (block.Statements.Count > 0 && block.Statements.Last() is IReturnStatement) { block.Statements.InsertRange(block.Statements.Count - 1, assumes); } else { block.Statements.AddRange(assumes); } } return(block); }
public IReadOnlyCollection <ActionQuery> CreateNegativeQueries(State state, Action action, IEnumerable <Action> actions) { var queryGenerator = new CciNegativeActionQueryGenerator(host); return(CreateQueries(state, action, actions, queryGenerator)); }