protected bool CheckInvariant(Formula invariant, params IComponent[] components)
{
var analysisTestsVariant = (AnalysisTestsVariant)Arguments[0];
var logAction = (Action <string>)(message => Output.Log("{0}", message));
analysisTestsVariant.CreateModelChecker(SuppressCounterExampleGeneration, logAction);
var model = TestModel.InitializeModel(components);
var useCheckInvariantsInsteadOfCheckInvariant = Arguments.Length > 1 && (bool)Arguments[1];
if (useCheckInvariantsInsteadOfCheckInvariant)
{
var modelFromFormulasGenerator = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var results = analysisTestsVariant.CheckInvariants(modelFromFormulasGenerator, invariant);
CounterExample = results[0].CounterExample;
return(results[0].FormulaHolds);
}
var modelGenerator = SafetySharpRuntimeModel.CreateExecutedModelCreator(model, invariant);
Result = analysisTestsVariant.CheckInvariant(modelGenerator, invariant);
CounterExample = Result.CounterExample;
return(Result.FormulaHolds);
}
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}");
}
protected bool Check(Formula formula, params IComponent[] components)
{
var modelChecker = CreateModelChecker();
var result = modelChecker.Check(TestModel.InitializeModel(components), formula);
CounterExample = result.CounterExample;
return(result.FormulaHolds);
}
protected bool Check(Formula formula, params IComponent[] components)
{
var analysisTestsVariant = (AnalysisTestsVariant)Arguments[0];
var modelCreator = SafetySharpRuntimeModel.CreateExecutedModelCreator(TestModel.InitializeModel(components), formula);
analysisTestsVariant.SetModelCheckerParameter(SuppressCounterExampleGeneration, Output.TextWriterAdapter());
analysisTestsVariant.SetExecutionParameter(AllowFaultsOnInitialTransitions);
var result = analysisTestsVariant.Check(modelCreator, formula);
CounterExample = result.ExecutableCounterExample(modelCreator);
return(result.FormulaHolds);
}
protected bool[] CheckInvariants(IComponent component, params Formula[] invariants)
{
var analysisTestsVariant = (AnalysisTestsVariant)Arguments[0];
var modelCreator = SafetySharpRuntimeModel.CreateExecutedModelCreator(TestModel.InitializeModel(component), invariants);
analysisTestsVariant.SetModelCheckerParameter(SuppressCounterExampleGeneration, Output.TextWriterAdapter());
analysisTestsVariant.SetExecutionParameter(AllowFaultsOnInitialTransitions);
var results = analysisTestsVariant.CheckInvariants(modelCreator, invariants);
CounterExamples = results.Select(result => result.ExecutableCounterExample(modelCreator)).ToArray();
return(results.Select(result => result.FormulaHolds).ToArray());
}
protected bool Check(Formula formula, params IComponent[] components)
{
var analysisTestsVariant = (AnalysisTestsVariant)Arguments[0];
var logAction = (Action <string>)(message => Output.Log("{0}", message));
analysisTestsVariant.CreateModelChecker(SuppressCounterExampleGeneration, logAction);
var modelCreator = SafetySharpRuntimeModel.CreateExecutedModelCreator(TestModel.InitializeModel(components), formula);
var result = analysisTestsVariant.Check(modelCreator, formula);
CounterExample = result.CounterExample;
return(result.FormulaHolds);
}
protected void GenerateCode(SerializationMode mode, params object[] objects)
{
objects = SerializationRegistry.Default.GetReferencedObjects(objects, mode).ToArray();
var model = TestModel.InitializeModel(new DummyComponent(objects));
_objectTable = new ObjectTable(objects);
StateVectorLayout = SerializationRegistry.Default.GetStateVectorLayout(model, _objectTable, mode);
_serializer = StateVectorLayout.CreateSerializer(_objectTable);
_deserializer = StateVectorLayout.CreateDeserializer(_objectTable);
_rangeRestrictor = StateVectorLayout.CreateRangeRestrictor(_objectTable);
StateSlotCount = StateVectorLayout.SizeInBytes / 4;
StateVectorSize = StateVectorLayout.SizeInBytes;
_buffer = new MemoryBuffer();
_buffer.Resize(StateVectorSize, zeroMemory: true);
SerializedState = _buffer.Pointer;
Output.Log("{0}", StateVectorLayout);
}
protected void GenerateStateSpace(params IComponent[] components)
{
var serializer = new RuntimeModelSerializer();
serializer.Serialize(TestModel.InitializeModel(components), new StateFormula(() => true));
var configuration = AnalysisConfiguration.Default;
configuration.StateCapacity = 10000;
configuration.StackCapacity = 10000;
configuration.CpuCount = 1;
var checker = new InvariantChecker(serializer.Load, s => Output.Log("{0}", s), configuration);
_result = checker.Check();
CounterExample.ShouldBe(null);
Output.Log($"States: {_result.StateCount}");
Output.Log($"Actual Transitions: {_result.TransitionCount}");
Output.Log($"Computed Transitions: {_result.ComputedTransitionCount}");
}
protected bool CheckInvariant(Formula invariant, params IComponent[] components)
{
var analysisTestsVariant = (AnalysisTestsVariant)Arguments[0];
analysisTestsVariant.SetModelCheckerParameter(SuppressCounterExampleGeneration, Output.TextWriterAdapter());
analysisTestsVariant.SetExecutionParameter(AllowFaultsOnInitialTransitions);
var modelCreator = SafetySharpRuntimeModel.CreateExecutedModelCreator(TestModel.InitializeModel(components), invariant);
var useCheckInvariantsInsteadOfCheckInvariant = Arguments.Length > 1 && (bool)Arguments[1];
if (useCheckInvariantsInsteadOfCheckInvariant)
{
var results = analysisTestsVariant.CheckInvariants(modelCreator, invariant);
CounterExample = results[0].ExecutableCounterExample(modelCreator);
return(results[0].FormulaHolds);
}
Result = analysisTestsVariant.CheckInvariant(modelCreator, invariant);
CounterExample = Result.ExecutableCounterExample(modelCreator);
return(Result.FormulaHolds);
}
protected SafetyAnalysisResults <SafetySharpRuntimeModel> DccaWithMaxCardinality(Formula hazard, int maxCardinality, ModelCapacity capacity, params IComponent[] components)
{
return(DccaWithMaxCardinality(TestModel.InitializeModel(components), hazard, maxCardinality, capacity));
}
protected bool[] CheckInvariants(IComponent component, params Formula[] invariants)
{
var analysisTestsVariant = (AnalysisTestsVariant)Arguments[0];
var logAction = (Action <string>)(message => Output.Log("{0}", message));
analysisTestsVariant.CreateModelChecker(SuppressCounterExampleGeneration, logAction);
var modelCreator = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(TestModel.InitializeModel(component));
var results = analysisTestsVariant.CheckInvariants(modelCreator, invariants);
CounterExamples = results.Select(result => result.CounterExample).ToArray();
return(results.Select(result => result.FormulaHolds).ToArray());
}
protected SafetyAnalysis.Result DccaWithMaxCardinality(Formula hazard, int maxCardinality, params IComponent[] components)
{
return(DccaWithMaxCardinality(TestModel.InitializeModel(components), hazard, maxCardinality));
}
