protected override void Check()
{
var c = new C();
var directModel = InitializeModel(c);
((C.Effect1)c.FaultEffects[0]).F = 17;
_hasConstructorRun = false;
var newModelInstanceBySerializeDeserialize = SafetySharpRuntimeModel.CreateExecutedModelCreator(directModel).Create(0);
//"Create" serializes and deserializes again (second time)
Create(newModelInstanceBySerializeDeserialize.Model);
ExecutableStateFormulas.ShouldBeEmpty();
RootComponents.Length.ShouldBe(1);
var root = RootComponents[0];
root.ShouldBeOfType <C.Effect1>();
root.GetSubcomponents().ShouldBeEmpty();
((C)root).F1.ShouldBeOfType <TransientFault>();
((C.Effect1)root).F.ShouldBe(17);
root.FaultEffects.Count.ShouldBe(1);
((C.Effect1)root.FaultEffects[0]).F.ShouldBe(17);
typeof(C.Effect1).GetField("__fault__", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(root).ShouldBe(((C)root).F1);
_hasConstructorRun.ShouldBe(false);
}
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}");
}
/// <summary>
/// Checks whether the <paramref name="formula" /> holds in all states of the <paramref name="model" />. The appropriate model
/// checker is chosen automatically.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="formula">The formula that should be checked.</param>
public static SafetySharpInvariantAnalysisResult Check(ModelBase model, Formula formula)
{
var createModel = SafetySharpRuntimeModel.CreateExecutedModelCreator(model, formula);
var result = new LtsMin().Check(createModel, formula);
return(SafetySharpInvariantAnalysisResult.FromInvariantAnalysisResult(result, createModel));
}
/// <summary>
/// Checks whether the <paramref name="invariant" /> holds in all states of the <paramref name="model" />. The appropriate
/// model checker is chosen automatically.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="invariant">The invariant that should be checked.</param>
public static AnalysisResult <SafetySharpRuntimeModel> CheckInvariant(ModelBase model, Formula invariant)
{
var createModel = SafetySharpRuntimeModel.CreateExecutedModelCreator(model, invariant);
var qualitativeChecker = new QualitativeChecker <SafetySharpRuntimeModel> {
Configuration = TraversalConfiguration
};
return(qualitativeChecker.CheckInvariant(createModel, formulaIndex: 0));
}
/// <summary>
/// Checks whether the <paramref name="invariant" /> holds in all states of the <paramref name="model" />. The appropriate
/// model checker is chosen automatically.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="invariant">The invariant that should be checked.</param>
public static SafetySharpInvariantAnalysisResult CheckInvariant(ModelBase model, Formula invariant)
{
var createModel = SafetySharpRuntimeModel.CreateExecutedModelCreator(model, invariant);
var qualitativeChecker = new QualitativeChecker <SafetySharpRuntimeModel>(createModel)
{
Configuration = TraversalConfiguration
};
var result = qualitativeChecker.CheckInvariant(formulaIndex: 0);
return(SafetySharpInvariantAnalysisResult.FromInvariantAnalysisResult(result, createModel));
}
/// <summary>
/// Checks whether the <paramref name="invariants" /> hold in all states of the <paramref name="model" />. The appropriate
/// model checker is chosen automatically.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="invariants">The invariants that should be checked.</param>
public static SafetySharpInvariantAnalysisResult[] CheckInvariants(ModelBase model, params Formula[] invariants)
{
var createModel = SafetySharpRuntimeModel.CreateExecutedModelCreator(model, invariants);
var qualitativeChecker = new QualitativeChecker <SafetySharpRuntimeModel>(createModel)
{
Configuration = TraversalConfiguration
};
var results = qualitativeChecker.CheckInvariants(invariants);
var newResults = results.Select(result => SafetySharpInvariantAnalysisResult.FromInvariantAnalysisResult(result, createModel));
return(newResults.ToArray());
}
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 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);
}
/// <summary>
/// Checks whether the <paramref name="formula" /> holds in all states of the <paramref name="model" />. The appropriate model
/// checker is chosen automatically.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="formula">The formula that should be checked.</param>
public static AnalysisResult <SafetySharpRuntimeModel> Check(ModelBase model, Formula formula)
{
return(new LtsMin().Check(SafetySharpRuntimeModel.CreateExecutedModelCreator(model, formula), formula));
}