/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="createModel">Creates the model that should be checked.</param>
/// <param name="output">The callback that should be used to output messages.</param>
/// <param name="configuration">The analysis configuration that should be used.</param>
/// <param name="stateFormula">The analyzed stateFormula.</param>
internal InvariantChecker(AnalysisModelCreator <TExecutableModel> createModel, Action <string> output, AnalysisConfiguration configuration, Formula stateFormula)
: base(createModel, output, configuration, 0)
{
var formulasToCheck = AnalyzedModels.First().RuntimeModel.Formulas;
Context.TraversalParameters.TransitionActions.Add(() => new InvariantViolationAction <TExecutableModel>(formulasToCheck, stateFormula));
}
/// <summary>
/// Generates a <see cref="LabeledTransitionMarkovDecisionProcess" /> for the model created by <paramref name="createModel" />.
/// </summary>
/// <param name="createModel">Creates the model that should be checked.</param>
internal LabeledTransitionMarkovDecisionProcess GenerateLtmdp(AnalysisModelCreator createModel)
{
using (var modelTraverser = new ModelTraverser(createModel, Configuration, LabeledTransitionMarkovDecisionProcess.TransitionSize,
FormulaManager.NeedsStutteringState))
{
_mdp = new LabeledTransitionMarkovDecisionProcess(modelTraverser.Context.ModelCapacity.NumberOfStates, modelTraverser.Context.ModelCapacity.NumberOfTransitions);
_mdp.StateFormulaLabels = FormulaManager.FinalStateFormulaLabels.ToArray();
if (FormulaManager.NeedsStutteringState)
{
_mdp.CreateStutteringState(modelTraverser.Context.StutteringStateIndex);
}
modelTraverser.Context.TraversalParameters.TransitionModifiers.AddRange(FormulaManager.TransitionModifierGenerators);
modelTraverser.Context.TraversalParameters.BatchedTransitionActions.Add(() => new LabeledTransitionMarkovDecisionProcess.LtmdpBuilderDuringTraversal(_mdp));
modelTraverser.Context.Output.WriteLine("Generating labeled transition markov decision process.");
modelTraverser.TraverseModelAndReport();
// StateStorage must be freed manually. Reason is that invariant checker does not free up the
// space, because it might be necessary for other usages of the ModelTraversers (e.g. StateGraphGenerator
// which keeps the States for the StateGraph)
modelTraverser.Context.States.SafeDispose();
}
if (Configuration.WriteGraphvizModels)
{
FormulaManager.PrintStateFormulas(FormulaManager.FinalStateFormulas, Configuration.DefaultTraceOutput);
Configuration.DefaultTraceOutput.WriteLine("Ltmdp Model");
_mdp.ExportToGv(Configuration.DefaultTraceOutput);
}
return(_mdp);
}
/// <summary>
/// Initializes the model that should be analyzed.
/// </summary>
/// <param name="configuration">The configuration that should be used for the analyses.</param>
/// <param name="hazard">The hazard that should be analyzed.</param>
protected override void InitializeModel(AnalysisConfiguration configuration, Formula hazard)
{
var invariant = new UnaryFormula(hazard, UnaryOperator.Not);
var checker = new QualitativeChecker <TExecutableModel>(RuntimeModelCreator)
{
Configuration = configuration
};
checker.Configuration.ProgressReportsOnly = false;
var stateGraph = checker.GenerateStateGraph();
var stateCapacity = Math.Max(1024, (int)(stateGraph.StateCount * 1.5));
var newModelCapacity = new ModelCapacityByModelDensity(stateCapacity, ModelDensityLimit.High);
configuration.ModelCapacity = newModelCapacity;
Func <AnalysisModel> createAnalysisModelFunc = () => new StateGraphModel <TExecutableModel>(stateGraph, configuration.SuccessorCapacity);
var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc);
_checker = new InvariantChecker(createAnalysisModel, configuration, invariant);
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="createModel">Creates the model that should be checked.</param>
/// <param name="configuration">The analysis configuration that should be used.</param>
/// <param name="stateFormula">The analyzed stateFormula.</param>
internal InvariantChecker(AnalysisModelCreator createModel, AnalysisConfiguration configuration, Formula stateFormula)
{
ModelTraverser = new ModelTraverser(createModel, configuration, 0, false);
var formulasToCheck = ModelTraverser.AnalyzedModels.First().Formulas;
ModelTraverser.Context.TraversalParameters.TransitionActions.Add(() => new InvariantViolationAction(formulasToCheck, stateFormula));
}
/// <summary>
/// Generates a <see cref="MarkovDecisionProcess" /> for the model created by <paramref name="createModel" />.
/// </summary>
public NestedMarkovDecisionProcess GenerateMarkovDecisionProcess(Formula terminateEarlyCondition = null)
{
Requires.That(IntPtr.Size == 8, "Model checking is only supported in 64bit processes.");
ProbabilityMatrixCreationStarted = true;
CollectStateFormulasVisitor stateFormulaCollector;
if (Configuration.UseAtomarPropositionsAsStateLabels)
{
stateFormulaCollector = new CollectAtomarPropositionFormulasVisitor();
}
else
{
stateFormulaCollector = new CollectMaximalCompilableFormulasVisitor();
}
foreach (var stateFormula in _formulasToCheck)
{
stateFormulaCollector.VisitNewTopLevelFormula(stateFormula);
}
if (terminateEarlyCondition)
{
stateFormulaCollector.VisitNewTopLevelFormula(terminateEarlyCondition);
}
var stateFormulas = stateFormulaCollector.CollectedStateFormulas.ToArray();
ExecutedModel <TExecutableModel> model = null;
var modelCreator = _runtimeModelCreator.CreateCoupledModelCreator(stateFormulas);
Func <AnalysisModel <TExecutableModel> > createAnalysisModelFunc = () =>
model = new LtmdpExecutedModel <TExecutableModel>(modelCreator, 0, Configuration.SuccessorCapacity);
var createAnalysisModel = new AnalysisModelCreator <TExecutableModel>(createAnalysisModelFunc);
return(GenerateMarkovDecisionProcess(createAnalysisModel, terminateEarlyCondition, stateFormulas));
}
protected void GenerateStateSpace(params IComponent[] components)
{
_modelCreator = SafetySharpRuntimeModel.CreateExecutedModelCreator(TestModel.InitializeModel(components), new ExecutableStateFormula(() => true));
var configuration = AnalysisConfiguration.Default;
configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
configuration.StackCapacity = 10000;
configuration.CpuCount = 1;
configuration.DefaultTraceOutput = Output.TextWriterAdapter();
configuration.AllowFaultsOnInitialTransitions = AllowFaultsOnInitialTransitions;
var analysisModelCreator = new AnalysisModelCreator(() => new ActivationMinimalExecutedModel <SafetySharpRuntimeModel>(_modelCreator, 0, configuration));
var checker = new InvariantChecker(analysisModelCreator,
configuration,
formulaIndex: 0);
_result = checker.Check();
CounterExample.ShouldBe(null);
Output.Log($"States: {_result.StateCount}");
Output.Log($"Actual Transitions: {_result.TransitionCount}");
Output.Log($"Computed Transitions: {_result.ComputedTransitionCount}");
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="createModel">Creates the model that should be checked.</param>
/// <param name="output">The callback that should be used to output messages.</param>
/// <param name="configuration">The analysis configuration that should be used.</param>
internal ModelTraverser(AnalysisModelCreator createModel, AnalysisConfiguration configuration, int transitionSize, bool createStutteringState)
{
Requires.NotNull(createModel, nameof(createModel));
var stopwatch = new Stopwatch();
stopwatch.Start();
TransitionCollection.ValidateTransitionSizes();
var tasks = new Task[configuration.CpuCount];
var stacks = new StateStack[configuration.CpuCount];
_loadBalancer = new LoadBalancer(stacks);
Context = new TraversalContext(_loadBalancer, configuration);
_workers = new Worker[configuration.CpuCount];
for (var i = 0; i < configuration.CpuCount; ++i)
{
var index = i;
tasks[i] = Task.Factory.StartNew(() =>
{
stacks[index] = new StateStack(configuration.StackCapacity);
_workers[index] = new Worker(index, Context, stacks[index], createModel.Create());
});
}
Task.WaitAll(tasks);
var firstModel = _workers[0].Model;
if (transitionSize == DeriveTransitionSizeFromModel)
{
transitionSize = firstModel.TransitionSize;
}
if (configuration.WriteStateVectorLayout)
{
firstModel.WriteStateVectorLayout(configuration.DefaultTraceOutput);
}
var modelCapacity = configuration.ModelCapacity.DeriveModelByteSize(firstModel.ModelStateVectorSize, transitionSize);
Context.ModelCapacity = modelCapacity;
if (configuration.UseCompactStateStorage)
{
_states = new CompactStateStorage(modelCapacity.SizeOfState, modelCapacity.NumberOfStates);
}
else
{
_states = new SparseStateStorage(modelCapacity.SizeOfState, modelCapacity.NumberOfStates);
}
Context.States = _states;
if (createStutteringState)
{
Context.StutteringStateIndex = _states.ReserveStateIndex();
}
_initializationTime = stopwatch.Elapsed;
stopwatch.Stop();
}
public void AnalysisModelCreatorsAreIndependent()
{
var other = new AnalysisModelCreator();
var f1 = other.GetFactory <TestAnalysisCircuitModel>();
var f2 = creator.GetFactory <TestAnalysisCircuitModel>();
Assert.NotEqual(f1, f2);
}
/// <summary>
/// Initizializes the model that should be analyzed.
/// </summary>
/// <param name="configuration">The configuration that should be used for the analyses.</param>
/// <param name="hazard">The hazard that should be analyzed.</param>
protected override void InitializeModel(AnalysisConfiguration configuration, Formula hazard)
{
Func <AnalysisModel> createAnalysisModelFunc = () =>
new ActivationMinimalExecutedModel <TExecutableModel>(RuntimeModelCreator, 0, configuration);
var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc);
var invariant = new UnaryFormula(hazard, UnaryOperator.Not);
_invariantChecker = new InvariantChecker(createAnalysisModel, configuration, invariant);
}
/// <summary>
/// Initizializes the model that should be analyzed.
/// </summary>
/// <param name="configuration">The configuration that should be used for the analyses.</param>
/// <param name="hazard">The hazard that should be analyzed.</param>
protected override void InitializeModel(AnalysisConfiguration configuration, Formula hazard)
{
Func <AnalysisModel <TExecutableModel> > createAnalysisModelFunc = () =>
new ActivationMinimalExecutedModel <TExecutableModel>(RuntimeModelCreator, _stateHeaderBytes, configuration.SuccessorCapacity);
var createAnalysisModel = new AnalysisModelCreator <TExecutableModel>(createAnalysisModelFunc);
var invariant = new UnaryFormula(hazard, UnaryOperator.Not);
_invariantChecker = new InvariantChecker <TExecutableModel>(createAnalysisModel, OnOutputWritten, configuration, invariant);
}
/// <summary>
/// Generates a <see cref="MarkovDecisionProcess" /> for the model created by <paramref name="createModel" />.
/// </summary>
private NestedMarkovDecisionProcess GenerateMarkovDecisionProcess(AnalysisModelCreator <TExecutableModel> createModel, Formula terminateEarlyCondition, Formula[] executableStateFormulas)
{
using (var checker = new LtmdpGenerator <TExecutableModel>(createModel, terminateEarlyCondition, executableStateFormulas, OutputWritten, Configuration))
{
var ltmdp = checker.GenerateStateGraph();
var ltmdpToNmdp = new LtmdpToNmdp(ltmdp);
var nmdp = ltmdpToNmdp.NestedMarkovDecisionProcess;
return(nmdp);
}
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="createModel">Creates the model that should be checked.</param>
/// <param name="output">The callback that should be used to output messages.</param>
/// <param name="configuration">The analysis configuration that should be used.</param>
internal StateGraphGenerator(AnalysisModelCreator <TExecutableModel> createModel,
Action <string> output, AnalysisConfiguration configuration)
: base(createModel, output, configuration, DeriveTransitionSizeFromModel)
{
var analyzedModel = AnalyzedModels.First();
_stateGraph = new StateGraph <TExecutableModel>(
Context, analyzedModel.TransitionSize,
analyzedModel.RuntimeModel, analyzedModel.RuntimeModelCreator);
Context.TraversalParameters.BatchedTransitionActions.Add(() => new StateGraphBuilder <TExecutableModel>(_stateGraph));
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="createModel">Creates the model that should be checked.</param>
/// <param name="configuration">The analysis configuration that should be used.</param>
internal StateGraphGenerator(AnalysisModelCreator createModel,
AnalysisConfiguration configuration)
{
_modelTraverser = new ModelTraverser(createModel, configuration, ModelTraverser.DeriveTransitionSizeFromModel, false);
var analyzedModel = _modelTraverser.AnalyzedModels.OfType <ExecutedModel <TExecutableModel> >().First();
_stateGraph = new StateGraph <TExecutableModel>(
_modelTraverser.Context, analyzedModel.TransitionSize,
analyzedModel.RuntimeModel, analyzedModel.RuntimeModelCreator);
_modelTraverser.Context.TraversalParameters.BatchedTransitionActions.Add(() => new StateGraphBuilder <TExecutableModel>(_stateGraph));
}
public LabeledTransitionMarkovChain GenerateLabeledMarkovChain()
{
FormulaManager.Calculate(Configuration);
var stateFormulasToCheckInBaseModel = FormulaManager.StateFormulasToCheckInBaseModel.ToArray();
var createModel = new AnalysisModelCreator(() => new LtmcRetraverseModel(_sourceLtmc, stateFormulasToCheckInBaseModel, Configuration));
Configuration.DefaultTraceOutput.WriteLine("Retraverse Model");
var labeledTransitionMarkovChain = GenerateLtmc(createModel);
return(labeledTransitionMarkovChain);
}
/// <summary>
/// Generates a <see cref="StateGraph{TExecutableModel}" /> for the model created by <paramref name="createModel" />.
/// </summary>
internal StateGraph <TExecutableModel> GenerateStateGraph()
{
// We have to track the state vector layout here; this will nondeterministically store some model instance of
// one of the workers; but since all state vectors are the same, we don't care
ExecutedModel <TExecutableModel> model = null;
Func <AnalysisModel> createAnalysisModelFunc = () =>
model = new ActivationMinimalExecutedModel <TExecutableModel>(ModelCreator, 0, Configuration);
var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc);
using (var checker = new StateGraphGenerator <TExecutableModel>(createAnalysisModel, Configuration))
{
var stateGraph = checker.GenerateStateGraph();
return(stateGraph);
}
}
/// <summary>
/// Checks the invariant encoded into the model created by <paramref name="createModel" />.
/// </summary>
public InvariantAnalysisResult CheckInvariant(int formulaIndex)
{
// We have to track the state vector layout here; this will nondeterministically store some model instance of
// one of the workers; but since all state vectors are the same, we don't care
ExecutedModel <TExecutableModel> model = null;
Func <AnalysisModel> createAnalysisModelFunc = () =>
model = new ActivationMinimalExecutedModel <TExecutableModel>(ModelCreator, 0, Configuration);
var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc);
using (var checker = new InvariantChecker(createAnalysisModel, Configuration, formulaIndex))
{
var result = checker.Check();
return(result);
}
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="createModel">Creates the model that should be checked.</param>
/// <param name="executableStateFormulas">The state formulas that can be evaluated over the generated state graph.</param>
/// <param name="output">The callback that should be used to output messages.</param>
/// <param name="configuration">The analysis configuration that should be used.</param>
internal LtmdpGenerator(AnalysisModelCreator <TExecutableModel> createModel, Formula terminateEarlyCondition, Formula[] executableStateFormulas,
Action <string> output, AnalysisConfiguration configuration)
: base(createModel, output, configuration, LabeledTransitionMarkovDecisionProcess.TransitionSize)
{
_mdp = new LabeledTransitionMarkovDecisionProcess(Context.ModelCapacity.NumberOfStates, Context.ModelCapacity.NumberOfTransitions);
_mdp.StateFormulaLabels = executableStateFormulas.Select(stateFormula => stateFormula.Label).ToArray();
Context.TraversalParameters.BatchedTransitionActions.Add(() => new LabeledTransitionMarkovDecisionProcess.LtmdpBuilderDuringTraversal <TExecutableModel>(_mdp, configuration));
if (terminateEarlyCondition != null)
{
_mdp.CreateStutteringState(Context.StutteringStateIndex);
var terminalteEarlyFunc = StateFormulaSetEvaluatorCompilationVisitor.Compile(_mdp.StateFormulaLabels, terminateEarlyCondition);
Context.TraversalParameters.TransitionModifiers.Add(() => new EarlyTerminationModifier <TExecutableModel>(terminalteEarlyFunc));
}
}
/// <summary>
/// Checks the invariant encoded into the model created by <paramref name="createModel" />.
/// </summary>
public AnalysisResult <TExecutableModel> CheckInvariant(CoupledExecutableModelCreator <TExecutableModel> createModel, Formula formula)
{
// We have to track the state vector layout here; this will nondeterministically store some model instance of
// one of the workers; but since all state vectors are the same, we don't care
ExecutedModel <TExecutableModel> model = null;
Func <AnalysisModel <TExecutableModel> > createAnalysisModelFunc = () =>
model = new ActivationMinimalExecutedModel <TExecutableModel>(createModel, 0, Configuration.SuccessorCapacity);
var createAnalysisModel = new AnalysisModelCreator <TExecutableModel>(createAnalysisModelFunc);
using (var checker = new InvariantChecker <TExecutableModel>(createAnalysisModel, OutputWritten, Configuration, formula))
{
var result = checker.Check();
return(result);
}
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="createModel">Creates the model that should be checked.</param>
/// <param name="output">The callback that should be used to output messages.</param>
/// <param name="configuration">The analysis configuration that should be used.</param>
internal ModelTraverser(AnalysisModelCreator <TExecutableModel> createModel, Action <string> output, AnalysisConfiguration configuration, int transitionSize)
{
Requires.NotNull(createModel, nameof(createModel));
Requires.NotNull(output, nameof(output));
var stopwatch = new Stopwatch();
stopwatch.Start();
TransitionCollection.ValidateTransitionSizes();
var tasks = new Task[configuration.CpuCount];
var stacks = new StateStack[configuration.CpuCount];
_loadBalancer = new LoadBalancer(stacks);
Context = new TraversalContext <TExecutableModel>(_loadBalancer, configuration, output);
_workers = new Worker <TExecutableModel> [configuration.CpuCount];
for (var i = 0; i < configuration.CpuCount; ++i)
{
var index = i;
tasks[i] = Task.Factory.StartNew(() =>
{
stacks[index] = new StateStack(configuration.StackCapacity);
_workers[index] = new Worker <TExecutableModel>(index, Context, stacks[index], createModel.Create());
});
}
Task.WaitAll(tasks);
var firstModel = _workers[0].Model;
if (transitionSize == DeriveTransitionSizeFromModel)
{
transitionSize = firstModel.TransitionSize;
}
var modelCapacity = configuration.ModelCapacity.DeriveModelByteSize(firstModel.StateVectorSize, transitionSize);
Context.ModelCapacity = modelCapacity;
_states = new StateStorage(modelCapacity.SizeOfState, modelCapacity.NumberOfStates);
Context.States = _states;
Context.StutteringStateIndex = _states.ReserveStateIndex();
_initializationTime = stopwatch.Elapsed;
stopwatch.Stop();
}
/// <summary>
/// Checks whether the <paramref name="invariant" /> holds in all states of the <paramref name="stateGraph" />.
/// </summary>
/// <param name="stateGraph">The state graph that should be checked.</param>
/// <param name="invariant">The invariant that should be checked.</param>
internal InvariantAnalysisResult CheckInvariant(StateGraph <TExecutableModel> stateGraph, Formula invariant)
{
Requires.NotNull(stateGraph, nameof(stateGraph));
Requires.NotNull(invariant, nameof(invariant));
// We have to track the state vector layout here; this will nondeterministically store some model instance of
// one of the workers; but since all state vectors are the same, we don't care
AnalysisModel model = null;
Func <AnalysisModel> createAnalysisModelFunc = () =>
model = new StateGraphModel <TExecutableModel>(stateGraph, Configuration.SuccessorCapacity);
var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc);
using (var checker = new InvariantChecker(createAnalysisModel, Configuration, invariant))
{
var result = checker.Check();
return(result);
}
}
/// <summary>
/// Generates a <see cref="MarkovDecisionProcess" /> for the model created by <paramref name="createModel" />.
/// </summary>
public LabeledTransitionMarkovDecisionProcess GenerateLabeledTransitionMarkovDecisionProcess()
{
Requires.That(IntPtr.Size == 8, "Model checking is only supported in 64bit processes.");
ProbabilityMatrixCreationStarted = true;
FormulaManager.Calculate(Configuration);
var stateFormulasToCheckInBaseModel = FormulaManager.StateFormulasToCheckInBaseModel.ToArray();
ExecutedModel <TExecutableModel> model = null;
var modelCreator = _runtimeModelCreator.CreateCoupledModelCreator(stateFormulasToCheckInBaseModel);
Func <AnalysisModel> createAnalysisModelFunc = () =>
model = new LtmdpExecutedModel <TExecutableModel>(modelCreator, Configuration);
var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc);
var ltmdp = GenerateLtmdp(createAnalysisModel);
return(ltmdp);
}
/// <summary>
/// Generates a <see cref="MarkovDecisionProcess" /> for the model created by <paramref name="createModel" />.
/// </summary>
private NestedMarkovDecisionProcess GenerateMarkovDecisionProcess(AnalysisModelCreator <TExecutableModel> createModel, Formula terminateEarlyCondition, Formula[] executableStateFormulas)
{
using (var checker = new LtmdpGenerator <TExecutableModel>(createModel, terminateEarlyCondition, executableStateFormulas, OutputWritten, Configuration))
{
PrintStateFormulas(executableStateFormulas);
var ltmdp = checker.GenerateStateGraph();
if (Configuration.WriteGraphvizModels)
{
Configuration.DefaultTraceOutput.WriteLine("Ltmdp Model");
ltmdp.ExportToGv(Configuration.DefaultTraceOutput);
}
var ltmdpToNmdp = new LtmdpToNmdp(ltmdp);
var nmdp = ltmdpToNmdp.NestedMarkovDecisionProcess;
if (Configuration.WriteGraphvizModels)
{
Configuration.DefaultTraceOutput.WriteLine("Nmdp Model");
nmdp.ExportToGv(Configuration.DefaultTraceOutput);
}
return(nmdp);
}
}
/// <summary>
/// Generates a <see cref="DiscreteTimeMarkovChain" /> for the model created by <paramref name="createModel" />.
/// </summary>
private DiscreteTimeMarkovChain GenerateMarkovChain(AnalysisModelCreator <TExecutableModel> createModel, Formula terminateEarlyCondition, Formula[] executableStateFormulas)
{
using (var checker = new LtmcGenerator <TExecutableModel>(createModel, terminateEarlyCondition, executableStateFormulas, OutputWritten, Configuration))
{
PrintStateFormulas(executableStateFormulas);
var labeledTransitionMarkovChain = checker.GenerateStateGraph();
if (Configuration.WriteGraphvizModels)
{
Configuration.DefaultTraceOutput.WriteLine("Ltmc Model");
labeledTransitionMarkovChain.ExportToGv(Configuration.DefaultTraceOutput);
}
var ltmcToMc = new LtmcToDtmc(labeledTransitionMarkovChain);
var markovChain = ltmcToMc.MarkovChain;
if (Configuration.WriteGraphvizModels)
{
Configuration.DefaultTraceOutput.WriteLine("Dtmc Model");
markovChain.ExportToGv(Configuration.DefaultTraceOutput);
}
return(markovChain);
}
}
public CircuitCalculationTests(ITestOutputHelper output) : base(output)
{
creator = new AnalysisModelCreator();
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="createModel">Creates the model that should be checked.</param>
/// <param name="output">The callback that should be used to output messages.</param>
/// <param name="configuration">The analysis configuration that should be used.</param>
/// <param name="formulaIndex">The zero-based index of the analyzed formula.</param>
internal InvariantChecker(AnalysisModelCreator <TExecutableModel> createModel, Action <string> output, AnalysisConfiguration configuration, int formulaIndex)
: base(createModel, output, configuration, 0)
{
Context.TraversalParameters.TransitionActions.Add(() => new InvariantViolationByIndexAction <TExecutableModel>(formulaIndex));
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="createModel">Creates the model that should be checked.</param>
/// <param name="configuration">The analysis configuration that should be used.</param>
/// <param name="formulaIndex">The zero-based index of the analyzed formula.</param>
internal InvariantChecker(AnalysisModelCreator createModel, AnalysisConfiguration configuration, int formulaIndex)
{
ModelTraverser = new ModelTraverser(createModel, configuration, 0, false);
ModelTraverser.Context.TraversalParameters.TransitionActions.Add(() => new InvariantViolationByIndexAction(formulaIndex));
}
public AnalysisModelFactoryTests()
{
definition = CircuitGenerator.GetCircuitWithBasicDevices();
creator = new AnalysisModelCreator();
}
