public override void WriteInternalStateStructure(ExecutableCounterExample <SimpleExecutableModel> counterExample, BinaryWriter writer)
{
// write meta data to validate that the right model was loaded
writer.Write(counterExample.RuntimeModel.Model.Faults.Length);
writer.Write(counterExample.RuntimeModel.Model.LocalBools.Length);
writer.Write(counterExample.RuntimeModel.Model.LocalInts.Length);
}
private bool CheckSet(FaultSet set, Fault[] allFaults, bool isHeuristicSuggestion, Activation activationMode)
{
try
{
var result = _backend.CheckCriticality(set, activationMode);
if (Configuration.CollectFaultSets)
{
if (!result.FormulaHolds)
{
if (!isHeuristicSuggestion)
{
ConsoleHelpers.WriteLine($" critical: {{ {set.ToString(allFaults)} }}", ConsoleColor.DarkRed);
}
_criticalSets.Add(set);
}
else if (isHeuristicSuggestion)
{
ConsoleHelpers.WriteLine($" safe: {{ {set.ToString(allFaults)} }} [heuristic]", ConsoleColor.Blue);
}
_checkedSets.Add(set);
}
_checkedSetCount++;
if (result.CounterExample != null)
{
var executableCounterExample = new ExecutableCounterExample <TExecutableModel>(_backend.RuntimeModelCreator.Create(0), result.CounterExample);
_counterExamples.Add(set, executableCounterExample);
}
return(result.FormulaHolds);
}
catch (AnalysisException e)
{
var heuristic = isHeuristicSuggestion ? " [heuristic]" : string.Empty;
ConsoleHelpers.WriteLine($" critical: {{ {set.ToString(allFaults)} }} {heuristic} [exception thrown]", ConsoleColor.DarkRed);
Console.WriteLine(e.InnerException);
if (Configuration.CollectFaultSets)
{
_checkedSets.Add(set);
}
_checkedSetCount++;
_criticalSets.Add(set);
_exceptions.Add(set, e.InnerException);
if (e.CounterExample != null)
{
var executableCounterExample = new ExecutableCounterExample <TExecutableModel>(_backend.RuntimeModelCreator.Create(0), e.CounterExample);
_counterExamples.Add(set, executableCounterExample);
}
return(false);
}
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="exception">The unhandled exception that was thrown during model checkinig.</param>
/// <param name="counterExample">The path through the model that leads to the <paramref name="exception" /> being thrown.</param>
public InvariantAnalysisException(Exception exception, TExecutableModel executableModel, CounterExample counterExample)
: base($"Error: An unhandled exception of type '{exception.GetType().FullName}' was " +
$"thrown during model checking: {exception.Message}", exception)
{
Requires.NotNull(exception, nameof(exception));
ExecutableModel = executableModel;
ExecutableCounterExample = new ExecutableCounterExample <TExecutableModel>(executableModel, counterExample);
CounterExample = counterExample;
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="counterExample">The counter example that should be simulated.</param>
public Simulator(CoupledExecutableModelCreator <TExecutableModel> modelCreator, CounterExample counterExample)
{
Requires.NotNull(counterExample, nameof(counterExample));
RuntimeModel = modelCreator.Create(0);
_counterExample = new ExecutableCounterExample <TExecutableModel>(RuntimeModel, counterExample);
Reset();
}
public Simulator(ExecutableCounterExample <TExecutableModel> counterExample)
{
Requires.NotNull(counterExample, nameof(counterExample));
RuntimeModel = counterExample.RuntimeModel;
_counterExample = counterExample;
Reset();
}
public override void WriteInternalStateStructure(ExecutableCounterExample <SafetySharpRuntimeModel> counterExample, BinaryWriter writer)
{
var formatter = new BinaryFormatter();
var memoryStream = new MemoryStream();
formatter.Serialize(memoryStream, counterExample.RuntimeModel.StateVectorLayout.ToArray());
var metadata = memoryStream.ToArray();
writer.Write(metadata.Length);
writer.Write(metadata);
}
protected void SimulateCounterExample(ExecutableCounterExample <SafetySharpRuntimeModel> counterExample, Action <SafetySharpSimulator> action)
{
// Test directly
action(new SafetySharpSimulator(counterExample));
// Test persisted
using (var file = new TemporaryFile(".ssharp"))
{
counterExample.Save(file.FilePath);
var counterExampleSerialization = new SafetySharpCounterExampleSerialization();
action(new SafetySharpSimulator(counterExampleSerialization.Load(file.FilePath)));
}
}
public LustreSimulator(ExecutableCounterExample <LustreExecutableModel> counterExample)
: base(counterExample)
{
}
public SafetySharpSimulator(ExecutableCounterExample <SafetySharpRuntimeModel> counterExample)
: base(counterExample)
{
}
public SimpleSimulator(ExecutableCounterExample <SimpleExecutableModel> counterExample)
: base(counterExample)
{
}
public override void WriteInternalStateStructure(ExecutableCounterExample <LustreExecutableModel> counterExample, BinaryWriter writer)
{
}
