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="result">The result of the analysis</param>
/// <param name="firstFault">The fault that must be activated first.</param>
/// <param name="secondFault">The fault that must be activated subsequently.</param>
/// <param name="kind">Determines the kind of the order relationship.</param>
internal OrderRelationship(InvariantAnalysisResult result, Fault firstFault, Fault secondFault, OrderRelationshipKind kind)
{
Requires.NotNull(result, nameof(result));
Requires.NotNull(firstFault, nameof(firstFault));
Requires.NotNull(secondFault, nameof(secondFault));
Requires.InRange(kind, nameof(kind));
Witness = result.CounterExample;
FirstFault = firstFault;
SecondFault = secondFault;
Kind = kind;
}
/// <summary>
/// Checks whether the <paramref name="invariants" /> holds in all states of the <paramref name="model" />.
/// </summary>
/// <param name="createModel">The creator for the model that should be checked.</param>
/// <param name="invariants">The invariants that should be checked.</param>
public InvariantAnalysisResult[] CheckInvariants(params Formula[] invariants)
{
Requires.NotNull(invariants, nameof(invariants));
Requires.That(invariants.Length > 0, nameof(invariants), "Expected at least one invariant.");
var qualitativeChecker = new QualitativeChecker <TExecutableModel>(ModelCreator);
qualitativeChecker.Configuration = Configuration;
var stateGraph = qualitativeChecker.GenerateStateGraph();
var results = new InvariantAnalysisResult[invariants.Length];
for (var i = 0; i < invariants.Length; ++i)
{
results[i] = qualitativeChecker.CheckInvariant(stateGraph, invariants[i]);
}
return(results);
}
public static SafetySharpInvariantAnalysisResult FromInvariantAnalysisResult(InvariantAnalysisResult result, CoupledExecutableModelCreator <SafetySharpRuntimeModel> modelCreator)
{
var executableModel = modelCreator?.Create(0);
var executableCounterExample = executableModel != null && result.CounterExample != null
? new ExecutableCounterExample <SafetySharpRuntimeModel>(executableModel, result.CounterExample)
: null;
var enhancedResult = new SafetySharpInvariantAnalysisResult
{
CounterExample = result.CounterExample,
ExecutableCounterExample = executableCounterExample,
FormulaHolds = result.FormulaHolds,
StateCount = result.StateCount,
TransitionCount = result.TransitionCount,
ComputedTransitionCount = result.TransitionCount,
LevelCount = result.LevelCount,
};
return(enhancedResult);
}
public static ExecutableCounterExample <TExecutableModel> ExecutableCounterExample <TExecutableModel>(this InvariantAnalysisResult result, CoupledExecutableModelCreator <TExecutableModel> modelCreator) where TExecutableModel : ExecutableModel <TExecutableModel>
{
if (result.CounterExample != null)
{
return(new ExecutableCounterExample <TExecutableModel>(modelCreator.Create(0), result.CounterExample));
}
return(null);
}
