public void CreateScenarioFromJson()
{
var scenario = ScenarioDescription.FromJson("scenario", @"[{'action':'Step2'}]", typeof(TestHost));
Assert.AreEqual(1, scenario.Steps.Count);
Assert.AreEqual(nameof(TestHost.Step2), scenario.Steps.First().Method.Name);
}
public void ScenarioPassesWithStep()
{
var scenario = new ScenarioDescription("scenario", TestHost.Step2);
var result = new ScenarioResult(scenario);
result.Run(new ScenarioContext());
Assert.IsFalse(result.Failed);
}
public void Initialize(List <Fluent> fluents, List <WorldAction> actions, List <WorldDescriptionRecord> statements, int maxTime)
{
ActionAdd.SetActions(actions);
_scenarioDescription = new ScenarioDescription();
_fluents = fluents;
InitializeStatements(statements);
this.ObservationAdd.Fluents = new ObservableCollection <Fluent>(fluents);
this.ActionAdd.MaxTime = maxTime;
this.ObservationAdd.MaxTime = maxTime;
}
static string CreateScenarioSourceCode(ScenarioDescription scenarioDescription)
{
var(friendlyNameAttribute, descriptionAttribute) = CreateFriendlyNameAndDescriptionAttributes(scenarioDescription);
var requiresAttributes = CreateRequiresAttributes(scenarioDescription);
return
($"{requiresAttributes}" +
$"{friendlyNameAttribute}" +
$"{descriptionAttribute}" +
$"public class {scenarioDescription.Name} : IScenario {{}}{Environment.NewLine}");
}
public DataXDeployJob(AppConfig config, ILogger logger)
{
_config = config;
_logger = logger;
_scenario = new ScenarioDescription("DataXMainline",
DataXHost.AcquireToken,
DataXHost.SaveJob,
DataXHost.GenerateConfigs,
DataXHost.RestartJob,
DataXHost.GetFlow
);
}
public DataXSchemaAndQueryJob(AppConfig config, ILogger logger)
{
_config = config;
_logger = logger;
_scenario = new ScenarioDescription("DataXSchemaAndQuery",
DataXHost.AcquireToken,
DataXHost.InferSchema,
DataXHost.InitializeKernel,
DataXHost.RefreshSampleAndKernel,
DataXHost.RefreshKernel,
DataXHost.RefreshSample
);
}
private bool CheckNearestObservation(ScenarioDescription scenarioDescription, int actualTime, int nextObservationTime, int nextTime)
{
if (actualTime <= nextObservationTime && nextObservationTime < nextTime)
{
ScenarioObservationRecord nextObservation = scenarioDescription.GetObservationFromTime(nextObservationTime);
if (!nextObservation.CheckState(ActualState, actualTime))
{
_logger.Warn("Leaf is incopatibile with observation!\n" +
"State: " + ActualState.ToString() +
"Observation: " + nextObservation);
return(false);
}
}
return(true);
}
public AccesibleConditionQuery(QuestionType questionType, string condition, ScenarioDescription scenario)
: base(QueryType.AccesibleCondition, questionType)
{
_queryType = QueryType.AccesibleCondition;
_condition = condition;
var logicExp = new SimpleLogicExpression(this._condition);
_fluentNames = logicExp.GetFluentNames();
_scenario = scenario;
ExecQuery = new ExecutableScenarioQuery(QuestionType.Ever, _scenario);
CondAtTimeQuery = new ConditionAtTimeQuery(QuestionType.Ever, _condition);
_logger.Info("Creates:\n " + this);
}
/// <summary>
/// Charge les données.
/// </summary>
async Task LoadData(bool firstLoad)
{
int projectId = ServiceBus.Get <IProjectManagerService>().CurrentProject.ProjectId;
ScenarioDescription currentScenario = ServiceBus.Get <IProjectManagerService>().CurrentScenario;
ShowSpinner();
try
{
RestitutionData data = await OnLoadData(projectId);
_allScenarios = data.Scenarios;
Scenarios = data.Scenarios
.Where(s => !s.IsDeleted)
.Select(s => new ScenarioSelection(s, s.IsShownInSummary, OnScenarioIsShownInSummaryChanged)).ToArray();
UdpateScenariosToShow();
if (SelectedView == null)
{
if (_restitutionState.Solutions)
{
SelectedView = _solutionsViewKey;
}
else
{
string key = ReferentialsUse.GetLabel(_restitutionState.Referential.Value);
SelectedView = key;
}
}
else
{
await _currentViewModel?.Refresh();
}
HideSpinner();
}
catch (Exception e)
{
base.OnError(e);
}
}
private void ButtonExecute_Click(object sender, RoutedEventArgs e)
{
// Wybieramy scenariusz wybrany w aktywnym oknie, jeśli nie jest wybrany to domyślnie bierzemy pierwszy
ScenarioDescription scenarioDescription = this._savedScenarios
.FirstOrDefault(t => t.Name.Equals(this._queriesControls[SelectedQueryType].SelectedScenario)) ?? this._savedScenarios.First();
try
{
Query q = this._queriesControls[this.SelectedQueryType].GetQuery(SelectedQuestionType);
QueryResult qr = Switcher.ExecuteQuery(q, scenarioDescription);
LabelResult.Content = qr;
LabelValidationMessage.Content = "";
}
catch (InvalidContentException exception)
{
LabelValidationMessage.Content = exception.Message;
LabelResult.Content = "";
}
}
private int GetNextTimestamp(ScenarioDescription scenarioDescription, int TInf)
{
int actualActionEndTime = int.MaxValue;
if (ActualWorldAction != null)
{
actualActionEndTime = ActualWorldAction.GetEndTime() < 0 ? int.MaxValue : ActualWorldAction.GetEndTime();
}
int nextActionStartTime = GetNextActionTime() < 0 ? int.MaxValue : GetNextActionTime();
int nextTimeForAction = Time == 0 ? 0 : Time + 1;
int nextActionTime = scenarioDescription.GetNextActionTime(nextTimeForAction);
nextActionTime = nextActionTime < 0 ? int.MaxValue : nextActionTime;
int min = Math.Min(nextActionTime, Math.Min(actualActionEndTime, nextActionStartTime));
return(min > TInf ? TInf : min);
}
private bool CheckNearestObservations(ScenarioDescription scenarioDescription, int nextTime)
{
int actualTime = Time;
while (actualTime <= nextTime)
{
int nextObservationTime = scenarioDescription.GetNextObservationTime(actualTime);
if (nextObservationTime == -1)
{
return(true);
}
if (!CheckNearestObservation(scenarioDescription, actualTime, nextObservationTime, nextTime))
{
return(false);
}
actualTime = nextObservationTime + 1;
}
return(true);
}
public void SetUp()
{
// BASIC WORLD DESCRIPTION
_worldDescription = new WorldDescription();
_worldDescription.Descriptions.Add(new Tuple <WorldDescriptionRecordType, WorldDescriptionRecord>(WorldDescriptionRecordType.Initially, new InitialRecord("a || b || c || d")));
_worldDescription.Descriptions.Add(new Tuple <WorldDescriptionRecordType, WorldDescriptionRecord>(WorldDescriptionRecordType.ActionCausesIf, new ActionCausesIfRecord(this._actionA2, "a && !b", "c")));
_worldDescription.Descriptions.Add(new Tuple <WorldDescriptionRecordType, WorldDescriptionRecord>(WorldDescriptionRecordType.ActionCausesIf, new ActionCausesIfRecord(this._actionB3, "a || b", "d")));
// BASIC SCENARIO
_scenarioDescription = new ScenarioDescription("basic");
_scenarioDescription.addObservation(new SimpleLogicExpression("a && b && c && d"), 0);
_scenarioDescription.addACS(this._actionA2, 1);
_scenarioDescription.addObservation(new SimpleLogicExpression("a && !b && c && d"), 4);
_reasoning = new Reasoning();
foreach (var description in _worldDescription.Descriptions.Select(t => t.Item2))
{
_reasoning.AddWorldDescriptionRecord(description);
}
}
private void AddScenario_Click(object sender, RoutedEventArgs e)
{
if (String.IsNullOrEmpty(ScenarioName))
{
LabelValidationScenario.Content = "It is necessary to fill scenario name.";
}
else
{
foreach (ScenarioDescription item in SavedScenarios)
{
if (item.Name == ScenarioName)
{
LabelValidationScenario.Content = "Scenario with this name already exists.";
return;
}
}
_scenarioDescription.Name = ScenarioName;
SavedScenarios.Add(_scenarioDescription);
_scenarioDescription = new ScenarioDescription();
ScenarioName = "";
CleanValues();
}
}
public void ExecutionSequenceByJson()
{
var scenario = ScenarioDescription.FromJson("scenario1", @"[{'action':'Step2'}, {'action':'FailedStep'}]", typeof(TestHost));
var result = new ScenarioResult(scenario);
var testContext = new ScenarioContext();
testContext["sequence"] = 1;
result.Run(testContext);
Assert.AreEqual(2, (int)testContext[nameof(TestHost.FailedStep)], scenario.Description);
Assert.AreEqual(1, (int)testContext[nameof(TestHost.Step2)], scenario.Description);
// change sequence and make sure that it is different this time
scenario = ScenarioDescription.FromJson("scenario2", @"[{'action':'FailedStep'}, {'action':'Step2'}]", typeof(TestHost));
result = new ScenarioResult(scenario);
testContext = new ScenarioContext();
testContext["sequence"] = 1;
result.Run(testContext);
Assert.AreEqual(1, (int)testContext[nameof(TestHost.FailedStep)], scenario.Description);
Assert.AreEqual(2, (int)testContext[nameof(TestHost.Step2)], scenario.Description);
}
public void ExecutionSequenceByMethod()
{
var scenario = new ScenarioDescription("scenario1", TestHost.FailedStep, TestHost.Step2);
var result = new ScenarioResult(scenario);
var testContext = new ScenarioContext();
testContext["sequence"] = 1;
result.Run(testContext);
Assert.AreEqual(1, (int)testContext[nameof(TestHost.FailedStep)], scenario.Description);
Assert.AreEqual(2, (int)testContext[nameof(TestHost.Step2)], scenario.Description);
// change sequence and make sure that it is different this time
scenario = new ScenarioDescription("scenario2", TestHost.Step2, TestHost.FailedStep);
result = new ScenarioResult(scenario);
testContext = new ScenarioContext();
testContext["sequence"] = 1;
result.Run(testContext);
Assert.AreEqual(2, (int)testContext[nameof(TestHost.FailedStep)], scenario.Description);
Assert.AreEqual(1, (int)testContext[nameof(TestHost.Step2)], scenario.Description);
}
public static QueryResult ExecuteQuery(Query query, ScenarioDescription scenarioDescription)
{
return(pageSwitcher.ExecuteQuery(query, scenarioDescription));
}
/// <summary>
/// Initialise une nouvelle instance de la classe <see cref="ScenarioChangedEvent"/>.
/// </summary>
/// <param name="sender">L'appelant.</param>
/// <param name="sd">Le scénario.</param>
public ScenarioChangedEvent(object sender, ScenarioDescription sd)
: base(sender)
{
this.Scenario = sd;
}
public ExecutableScenarioQuery(QuestionType questionType, ScenarioDescription scenario)
: base(QueryType.ExecutableScenario, questionType)
{
_scenario = scenario;
}
internal List <Vertex> GenerateChildsForLeaf(WorldDescription worldDescription, ScenarioDescription scenarioDescription, int TInf)
{
List <Vertex> vertices = new List <Vertex>();
int nextTime = GetNextTimestamp(scenarioDescription, TInf);
if (!CheckNearestObservations(scenarioDescription, nextTime))
{
return(GetImpossibleChilds());
}
var implications = worldDescription.GetImplications(this, nextTime);
WorldAction nextAction = scenarioDescription.GetActionAtTime(nextTime);
vertices = CreateChildsBasedOnImplications(implications, nextAction, nextTime);
return(vertices);
}
private List <State> CreateStatesBasedOnObservations(List <string> fluentNames, ScenarioDescription scenarioDescription, ref int time)
{
List <State> states = new List <State>();
time = scenarioDescription.GetNextObservationTime(0);
if (time == -1 || time > _TInf)
{
return(states);
}
ScenarioObservationRecord observation = scenarioDescription.GetObservationFromTime(time);
if (observation == null)
{
_logger.Warn("Scenario has no observations!");
State state = new State();
state.AddFluents(fluentNames);
states.Add(state);
}
else
{
_logicExpression = new SimpleLogicExpression(observation.Expr as SimpleLogicExpression);
List <Fluent[]> possibleInitialValues = _logicExpression.CalculatePossibleFluents();
foreach (var valuation in possibleInitialValues)
{
State state = new State();
state.AddFluents(fluentNames);
foreach (var fluent in valuation)
{
try
{
state.Fluents.First(f => f.Name == fluent.Name).Value = fluent.Value;
}
catch (System.ArgumentNullException)
{
_logger.Error("Fluent " + fluent.Name + " doesn't exist!");
}
}
states.Add(state);
}
}
return(states);
}
public QueryResult ExecuteQuery(Query query, ScenarioDescription scenarioDescription)
{
QueryResultsContainer queryResultsContainer = new QueryResultsContainer(query.questionType);
//tree initialization
Tree tree = new Tree(TInf);
//add first level
int numberOfImpossibleLeaf = 0;
tree.AddFirstLevel(worldDescription, scenarioDescription, out numberOfImpossibleLeaf);
queryResultsContainer.AddMany(QueryResult.False, numberOfImpossibleLeaf);
if (tree.LastLevel.Count > 0 && CheckIfLeafIsPossible(tree.LastLevel[0], scenarioDescription))
{
QueryResult result = query.CheckCondition(tree.LastLevel[0]);
if (result == QueryResult.True || result == QueryResult.False)
{
queryResultsContainer.AddMany(result);
}
}
//generate next level if query can't answer yet
while (!queryResultsContainer.CanQuickAnswer() && tree.LastLevel.Count > 0)
{
int childsCount = tree.LastLevel.Count;
for (int i = 0; i < childsCount; ++i)
{
Vertex leaf = tree.LastLevel[i];
if (!CheckIfLeafIsPossible(leaf, scenarioDescription))
{
tree.DeleteChild(i);
queryResultsContainer.AddMany(QueryResult.False);
if (queryResultsContainer.CanQuickAnswer())
{
break;
}
}
else
{
tree.DeleteChild(i);
List <Vertex> nextLevel = leaf.GenerateChildsForLeaf(worldDescription, scenarioDescription, TInf);
foreach (var child in nextLevel)
{
if (!CheckIfLeafIsPossible(child, scenarioDescription))
{
queryResultsContainer.AddMany(QueryResult.False);
if (queryResultsContainer.CanQuickAnswer())
{
break;
}
}
QueryResult result = query.CheckCondition(child);
if (result == QueryResult.True || result == QueryResult.False)
{
queryResultsContainer.AddMany(result);
}
else
{
tree.Add(child);
}
}
}
}
}
return(queryResultsContainer.CollectResults());
}
public QueryResult ExecuteQuery(Query query, ScenarioDescription scenarioDescription)
{
return(_reasoning.ExecuteQuery(query, scenarioDescription));
}
private bool CheckIfLeafIsPossible(Vertex leaf, ScenarioDescription scenarioDescription)
{
return(leaf.IsPossible && leaf.ValidateActions() && worldDescription.Validate(leaf) && scenarioDescription.CheckIfLeafIsPossible(leaf));
}
