public void Empty_Builder_Builds_Empty_Epa()
{
var dummyTypeDefinition = A.Dummy <ITypeDefinition>();
var epaBuilder = new EpaBuilder(dummyTypeDefinition);
var epa = epaBuilder.Build();
Assert.Equal(dummyTypeDefinition, epa.Type);
Assert.Empty(epa.Transitions);
Assert.Contains(CreateEmptyState(), epa.States);
Assert.Equal(1, epa.States.Count);
}
public void Empty_Builder_Should_Have_An_Empty_State_And_No_Transitions()
{
var dummyTypeDefinition = A.Dummy <ITypeDefinition>();
var epaBuilder = new EpaBuilder(dummyTypeDefinition);
Assert.Equal(dummyTypeDefinition, epaBuilder.Type);
var emptyState = CreateEmptyState();
Assert.Contains(emptyState, epaBuilder.States);
Assert.Equal(1, epaBuilder.States.Count);
Assert.Empty(epaBuilder.Transitions);
}
public async Task <TypeAnalysisResult> Start(AnalysisEventArgs analysisEventArgs)
{
cancellationSource = new CancellationTokenSource();
var analyzer = GetAnalyzerFactory(analysisEventArgs.TypeToAnalyze, analysisEventArgs.Engine, cancellationSource.Token);
var epaGenerator = new EpaGenerator(analyzer, -1);
var selectedMethods = from m in analysisEventArgs.SelectedMethods select m.ToString();
var epaBuilder = new EpaBuilder(analysisEventArgs.TypeToAnalyze);
OnInitialStateAdded(this, epaBuilder);
var epaBuilderObservable = new ObservableEpaBuilder(epaBuilder);
epaBuilderObservable.TransitionAdded += OnTransitionAdded;
return(await epaGenerator.GenerateEpa(analysisEventArgs.TypeToAnalyze, selectedMethods, epaBuilderObservable));
}
public void Add_Transition_With_Two_States()
{
var dummyTypeDefinition = A.Dummy <ITypeDefinition>();
var epaBuilder = new EpaBuilder(dummyTypeDefinition);
var action1 = A.Dummy <Action>();
A.CallTo(() => action1.Equals(action1)).Returns(true);
var action2 = A.Dummy <Action>();
A.CallTo(() => action2.Equals(action2)).Returns(true);
var dummyStateSrc =
A.Fake <State>(x => x.WithArgumentsForConstructor(() => new State(new HashSet <Action> {
action1
}, A.Dummy <ISet <Action> >())));
var dummyStateDest =
A.Fake <State>(x => x.WithArgumentsForConstructor(() => new State(new HashSet <Action> {
action2
}, A.Dummy <ISet <Action> >())));
var transition =
A.Fake <Transition>(x => x.WithArgumentsForConstructor(() => new Transition(action1, dummyStateSrc, dummyStateDest, false)));
epaBuilder.Add(transition);
Assert.Equal(1, epaBuilder.Transitions.Count);
Assert.Contains(transition, epaBuilder.Transitions);
Assert.Contains(dummyStateSrc, epaBuilder.States);
Assert.Contains(dummyStateDest, epaBuilder.States);
Assert.Contains(CreateEmptyState(), epaBuilder.States);
Assert.Equal(3, epaBuilder.States.Count);
Assert.Equal(dummyTypeDefinition, epaBuilder.Type);
}
public void Add_Transition_With_One_State()
{
var dummyTypeDefinition = A.Dummy <ITypeDefinition>();
var epaBuilder = new EpaBuilder(dummyTypeDefinition);
var dummyState = A.Dummy <State>();
var dummyAction = A.Dummy <Action>();
A.CallTo(() => dummyAction.Equals(dummyAction)).Returns(true);
var fakeTransition =
A.Fake <Transition>(x => x.WithArgumentsForConstructor(() => new Transition(dummyAction, dummyState, dummyState, false)));
epaBuilder.Add(fakeTransition);
Assert.Contains(fakeTransition, epaBuilder.Transitions);
Assert.Equal(1, epaBuilder.Transitions.Count);
Assert.Contains(dummyState, epaBuilder.States);
Assert.Contains(CreateEmptyState(), epaBuilder.States);
Assert.Equal(2, epaBuilder.States.Count);
Assert.Equal(dummyTypeDefinition, epaBuilder.Type);
}
protected static TypeAnalysisResult GenerateEpa(CciAssembly inputAssembly, ITypeDefinition typeToAnalyze, Options options)
{
System.Console.WriteLine("Starting analysis for type {0}", typeToAnalyze);
var cancellationSource = new CancellationTokenSource();
var workingDir = CreateOrCleanupWorkingDirectory();
var queryGenerator = new CciQueryGenerator();
IAnalyzerFactory analyzerFactory;
switch (options.Backend)
{
case "CodeContracts":
var codeContracts = Environment.GetEnvironmentVariable("CodeContractsInstallDir");
if (string.IsNullOrEmpty(codeContracts))
{
var msg = new StringBuilder();
msg.AppendLine("The environment variable %CodeContractsInstallDir% does not exist.");
msg.AppendLine("Please make sure that Code Contracts is installed correctly.");
msg.AppendLine("This might be because the system was not restarted after Code Contracts installation.");
throw new DirectoryNotFoundException(msg.ToString());
}
var cccheckArgs = ConfigurationManager.AppSettings["CccheckArgs"];
Contract.Assert(cccheckArgs != null);
var cccheck = new FileInfo(ConfigurationManager.AppSettings["CccheckFullName"]);
Contract.Assert(cccheck.Exists);
analyzerFactory = new CodeContractsAnalyzerFactory(workingDir, cccheckArgs, string.Empty, queryGenerator, inputAssembly,
options.InputAssembly,
typeToAnalyze, cancellationSource.Token);
break;
case "Corral":
var corralDefaultArgs = ConfigurationManager.AppSettings["CorralDefaultArgs"];
Contract.Assert(corralDefaultArgs != null);
analyzerFactory = new CorralAnalyzerFactory(corralDefaultArgs, workingDir, queryGenerator, inputAssembly,
options.InputAssembly, typeToAnalyze, cancellationSource.Token);
break;
default:
throw new NotSupportedException();
}
var generator = new EpaGenerator(analyzerFactory, options.Cutter);
var epaBuilder = new EpaBuilder(typeToAnalyze);
var epaBuilderObservable = new ObservableEpaBuilder(epaBuilder);
epaBuilderObservable.TransitionAdded += OnTransitionAdded;
TypeAnalysisResult analysisResult;
if (!options.Methods.Equals("All"))
{
var selectedMethods = options.Methods.Split(';');
analysisResult = generator.GenerateEpa(typeToAnalyze, selectedMethods, epaBuilderObservable).Result;
}
else
{
analysisResult = generator.GenerateEpa(typeToAnalyze, epaBuilderObservable).Result;
}
return(analysisResult);
}
