/// <summary>
/// Sets the value of a specific variable
/// </summary>
/// <param name="variableName"></param>
/// <param name="value"></param>
public void SetVariableValue(string variableName, Value value)
{
EfsAccess.WaitOne();
try
{
if (Runner != null)
{
IVariable variable = EfsSystem.Instance.FindByFullName(variableName) as IVariable;
if (variable != null)
{
Util.DontNotify(() =>
{
Runner.CacheImpact = new CacheImpact();
SyntheticVariableUpdateAction action = new SyntheticVariableUpdateAction(variable,
value.ConvertBack(variable.Type));
VariableUpdate variableUpdate = new VariableUpdate(action, null, null);
Runner.EventTimeLine.AddModelEvent(variableUpdate, true);
Runner.ClearCaches();
});
}
else
{
throw new FaultException <EFSServiceFault> (
new EFSServiceFault("Cannot find variable " + variableName),
new FaultReason(new FaultReasonText("Cannot find variable " + variableName)));
}
}
}
finally
{
EfsAccess.ReleaseMutex();
}
}
/// <summary>
/// Handles a double click event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TimeLineControl_DoubleClick(object sender, EventArgs e)
{
ModelEvent evt = GetEventUnderMouse();
VariableUpdate variableUpdate = evt as VariableUpdate;
if (variableUpdate != null)
{
EditorView.Window form = new EditorView.Window();
TimeLineExpressionableTextChangeHandler handler = new TimeLineExpressionableTextChangeHandler(this,
variableUpdate.Action);
form.setChangeHandler(handler);
GuiUtils.MdiWindow.AddChildWindow(form, DockAreas.Float);
}
Expect expect = evt as Expect;
if (expect != null)
{
EditorView.Window form = new EditorView.Window();
TimeLineExpressionableTextChangeHandler handler = new TimeLineExpressionableTextChangeHandler(this,
expect.Expectation);
form.setChangeHandler(handler);
GuiUtils.MdiWindow.AddChildWindow(form, DockAreas.Float);
}
}
/// <summary>
/// Indicates that an event should be shown
/// </summary>
/// <param name="evt"></param>
/// <returns></returns>
public bool VisibleEvent(ModelEvent evt)
{
bool retVal = true;
// Check event type
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
retVal = retVal && (!(evt is Expect) || Expect);
retVal = retVal && (!(evt is RuleFired) || RuleFired);
// Ignore the following internal events
retVal = retVal && (!(evt is ExpectationStateChange));
retVal = retVal && (!(evt is SubStepActivated));
if (retVal)
{
// Checks the variable update
VariableUpdate variableUpdate = evt as VariableUpdate;
if (variableUpdate != null)
{
if (VariableUpdate)
{
// Do not filter out variables updates for which the rule is not available
// because these updates are related to test steps or external input (using EFS service)
if (variableUpdate.Action.RuleCondition != null)
{
retVal = false;
foreach (Variable variable in Variables)
{
retVal = variableUpdate.Changes.ImpactVariable(variable);
if (retVal)
{
break;
}
}
}
}
else
{
retVal = false;
}
}
else
{
// Check event namespace
if (evt.NameSpace != null)
{
retVal = NameSpaces.Contains(evt.NameSpace);
}
}
}
// Keep messages that match the regular expression
if (!Util.isEmpty(RegExp))
{
Regex regularExpression = new Regex(RegExp);
retVal = retVal || regularExpression.IsMatch(evt.Message);
}
return(retVal);
}
/// <summary>
/// Handles a double click event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TimeLineControl_DoubleClick(object sender, EventArgs e)
{
ModelEvent evt = GetEventUnderMouse();
VariableUpdate variableUpdate = evt as VariableUpdate;
if (variableUpdate != null)
{
ExplanationPart explain = variableUpdate.Explanation;
ExplainBox explainTextBox = new ExplainBox();
explainTextBox.SetExplanation(explain);
GuiUtils.MdiWindow.AddChildWindow(explainTextBox);
}
RuleFired rulefired = evt as RuleFired;
if (rulefired != null)
{
ExplanationPart explain = rulefired.Explanation;
ExplainBox explainTextBox = new ExplainBox();
explainTextBox.SetExplanation(explain);
GuiUtils.MdiWindow.AddChildWindow(explainTextBox);
}
Expect expect = evt as Expect;
if (expect != null)
{
Expectation expectation = expect.Expectation;
if (expectation != null)
{
ExplanationPart explanation = expect.Explanation;
if (explanation == null)
{
explanation = expectation.Explain;
}
ExplainBox explainTextBox = new ExplainBox();
explainTextBox.SetExplanation(explanation);
GuiUtils.MdiWindow.AddChildWindow(explainTextBox);
}
}
ModelInterpretationFailure modelInterpretationFailure = evt as ModelInterpretationFailure;
if (modelInterpretationFailure != null)
{
ExplainBox explainTextBox = new ExplainBox();
explainTextBox.SetExplanation(modelInterpretationFailure.Explanation);
GuiUtils.MdiWindow.AddChildWindow(explainTextBox);
}
}
/// <summary>
/// Handles a click event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TimeLineControl_Click(object sender, EventArgs e)
{
ModelEvent evt = GetEventUnderMouse();
RuleFired ruleFired = evt as RuleFired;
if (ruleFired != null)
{
EfsSystem.Instance.Context.SelectElement(ruleFired.RuleCondition, this,
Context.SelectionCriteria.LeftClick);
}
VariableUpdate variableUpdate = evt as VariableUpdate;
if (variableUpdate != null)
{
EfsSystem.Instance.Context.SelectElement(variableUpdate.Action, this,
Context.SelectionCriteria.LeftClick);
}
Expect expect = evt as Expect;
if (expect != null)
{
EfsSystem.Instance.Context.SelectElement(expect.Expectation, this, Context.SelectionCriteria.LeftClick);
}
ModelInterpretationFailure failure = evt as ModelInterpretationFailure;
if (failure != null)
{
EfsSystem.Instance.Context.SelectElement(failure.Instance as IModelElement, this,
Context.SelectionCriteria.LeftClick);
}
SubStepActivated subStepActivated = evt as SubStepActivated;
if (subStepActivated != null)
{
EfsSystem.Instance.Context.SelectElement(subStepActivated.SubStep, this,
Context.SelectionCriteria.LeftClick);
}
StepActivation stepActivation = evt as StepActivation;
if (stepActivation != null)
{
EfsSystem.Instance.Context.SelectElement(stepActivation.Step, this, Context.SelectionCriteria.LeftClick);
}
}
/// <summary>
/// Provides the color associated to a model event
/// </summary>
/// <param name="modelEvent"></param>
private void SetColor()
{
Color color = Color.Brown;
if (ModelEvent is RuleFired)
{
color = Color.Blue;
}
else if (ModelEvent is VariableUpdate)
{
VariableUpdate update = ModelEvent as VariableUpdate;
TestCase testCase = Utils.EnclosingFinder <TestCase> .find(update.Action);
if (testCase != null)
{
color = Color.LightGreen;
}
else
{
color = Color.BlanchedAlmond;
}
}
else if (ModelEvent is Expect)
{
Expect expect = ModelEvent as Expect;
switch (expect.State)
{
case Expect.EventState.Active:
color = Color.Silver;
break;
case Expect.EventState.Fullfilled:
color = Color.Gold;
break;
case Expect.EventState.TimeOut:
color = Color.Red;
break;
}
}
BackColor = color;
}
/// <summary>
/// Positions a substep in the time line
/// </summary>
/// <param name="currentTime"></param>
/// <param name="subStep"></param>
/// <returns></returns>
private void PositionSubStep(double currentTime, SubStep subStep)
{
SubStepActivated subStepActivated = new SubStepActivated(subStep, null)
{
Time = currentTime
};
PositionHandler.RegisterEvent(subStepActivated);
foreach (Action action in subStep.Actions)
{
VariableUpdate variableUpdate = new VariableUpdate(action, action, null);
PositionHandler.RegisterEvent(variableUpdate);
}
foreach (Expectation expectation in subStep.Expectations)
{
Expect expect = new Expect(expectation, null);
PositionHandler.RegisterEvent(expect);
}
}
/// <summary>
/// Applies the selected actions and update the system state
/// </summary>
/// <param name="activations"></param>
/// <param name="priority"></param>
/// <param name="updates">Provides all the updates that have been evaluated</param>
public void EvaluateActivations(HashSet <Activation> activations, acceptor.RulePriority?priority,
List <VariableUpdate> updates)
{
foreach (Activation activation in activations)
{
if (activation.RuleCondition.Actions.Count > 0)
{
// Register the fact that a rule has been triggered
RuleFired ruleFired = new RuleFired(activation, priority);
EventTimeLine.AddModelEvent(ruleFired, true);
ExplanationPart changesExplanation = ExplanationPart.CreateSubExplanation(activation.Explanation,
"Changes");
// Registers all model updates due to this rule triggering
foreach (Action action in activation.RuleCondition.Actions)
{
if (action.Statement != null)
{
VariableUpdate variableUpdate = new VariableUpdate(action, activation.Instance, priority);
variableUpdate.ComputeChanges(false, this);
EventTimeLine.AddModelEvent(variableUpdate, false);
ruleFired.AddVariableUpdate(variableUpdate);
if (changesExplanation != null)
{
changesExplanation.SubExplanations.Add(variableUpdate.Explanation);
}
updates.Add(variableUpdate);
}
else
{
action.AddError("Cannot parse action statement");
}
}
}
}
HandleEnterAndLeaveStateActions(priority, updates);
}
/// <summary>
/// Applies a specific statement on the model
/// </summary>
/// <param name="statementText"></param>
public void ApplyStatement(string statementText)
{
EfsAccess.WaitOne();
try
{
if (Runner != null)
{
const bool silent = true;
using (Parser parser = new Parser())
{
Statement statement = parser.Statement(EfsSystem.Instance.Dictionaries[0],
statementText, silent);
if (statement != null)
{
Util.DontNotify(() =>
{
Runner.CacheImpact = new CacheImpact();
Action action = (Action)acceptor.getFactory().createAction();
action.ExpressionText = statementText;
VariableUpdate variableUpdate = new VariableUpdate(action, null, null);
Runner.EventTimeLine.AddModelEvent(variableUpdate, true);
Runner.ClearCaches();
});
}
}
}
}
catch (Exception)
{
// TODO
}
finally
{
EfsAccess.ReleaseMutex();
}
}
/// <summary>
/// Click!
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void EventControl_Click(object sender, EventArgs e)
{
if (ModelEvent is RuleFired)
{
if (TimeLine.Window.MDIWindow.DataDictionaryWindow != null)
{
RuleFired ruleFired = ModelEvent as RuleFired;
TimeLine.Window.MDIWindow.DataDictionaryWindow.TreeView.Select(ruleFired.RuleCondition);
}
}
else if (ModelEvent is VariableUpdate)
{
VariableUpdate variableUpdate = ModelEvent as VariableUpdate;
if (isDoubleClick())
{
if (variableUpdate != null)
{
DataDictionary.Interpreter.ExplanationPart explain = variableUpdate.Explanation;
ExplainBox explainTextBox = new ExplainBox();
explainTextBox.setExplanation(explain);
MDIWindow.AddChildWindow(explainTextBox);
}
}
BaseTreeNode treeNode = null;
if (TimeLine.Window.MDIWindow.DataDictionaryWindow != null)
{
treeNode = TimeLine.Window.MDIWindow.DataDictionaryWindow.TreeView.Select(variableUpdate.Action);
}
if (treeNode == null)
{
if (TimeLine.Window.MDIWindow.TestWindow != null)
{
TimeLine.Window.MDIWindow.TestWindow.TreeView.Select(variableUpdate.Action);
}
}
}
else if (ModelEvent is Expect)
{
if (isDoubleClick())
{
DataDictionary.Tests.Expectation expectation = getExpectation();
if (expectation != null)
{
DataDictionary.Interpreter.ExplanationPart explain = expectation.ExpressionTree.Explain();
ExplainBox explainTextBox = new ExplainBox();
explainTextBox.setExplanation(explain);
MDIWindow.AddChildWindow(explainTextBox);
}
}
if (TimeLine.Window.MDIWindow.TestWindow != null)
{
TimeLine.Window.MDIWindow.TestWindow.TreeView.Select((ModelEvent as Expect).Expectation);
}
}
lastClick = DateTime.Now;
}
/// <summary>
/// Provides the display attributes for a model event
/// </summary>
/// <param name="evt"></param>
/// <returns></returns>
private EventDisplayAttributes GetDisplayAttributes(ModelEvent evt)
{
EventDisplayAttributes retVal = new EventDisplayAttributes(Color.White, new Pen(Color.Black), "<undefined>",
null, null, null);
ModelElement.DontRaiseError(() =>
{
Expect expect = evt as Expect;
if (expect != null)
{
string name = GuiUtils.AdjustForDisplay(ShortName(expect.Expectation.Name),
_eventSize.Width - 4, BottomFont);
switch (expect.State)
{
case Expect.EventState.Active:
retVal = new EventDisplayAttributes(Color.Violet, new Pen(Color.Black), name,
Images.Images[QuestionMarkImageIndex], NameSpaceImages.Instance.GetImage(expect.Expectation), null);
break;
case Expect.EventState.Fullfilled:
retVal = new EventDisplayAttributes(Color.LightGreen, new Pen(Color.Green), name,
Images.Images[SuccessImageIndex], NameSpaceImages.Instance.GetImage(expect.Expectation), null);
break;
case Expect.EventState.TimeOut:
retVal = new EventDisplayAttributes(Color.Red, new Pen(Color.DarkRed), name, Images.Images[ErrorImageIndex],
NameSpaceImages.Instance.GetImage(expect.Expectation), null);
break;
}
if (expect.Expectation.getKind() == acceptor.ExpectationKind.aContinuous)
{
retVal.TopRightIconImage.Add(Images.Images[CircularArrowIndex]);
}
if (expect.Expectation.Blocking)
{
retVal.TopRightIconImage.Add(Images.Images[DownArrowIndex]);
}
}
ModelInterpretationFailure modelInterpretationFailure = evt as ModelInterpretationFailure;
if (modelInterpretationFailure != null)
{
string name = GuiUtils.AdjustForDisplay(modelInterpretationFailure.Message,
_eventSize.Width - 4, BottomFont);
retVal = new EventDisplayAttributes(Color.Red, new Pen(Color.DarkRed), name, Images.Images[ErrorImageIndex],
NameSpaceImages.Instance.GetImage(modelInterpretationFailure.Instance as ModelElement), null);
}
RuleFired ruleFired = evt as RuleFired;
if (ruleFired != null)
{
string name = GuiUtils.AdjustForDisplay(ShortName(ruleFired.RuleCondition.Name),
_eventSize.Width - 4, BottomFont);
retVal = new EventDisplayAttributes(Color.LightBlue, new Pen(Color.Blue), name, null,
NameSpaceImages.Instance.GetImage(ruleFired.RuleCondition), Images.Images[ToolsImageIndex]);
}
VariableUpdate variableUpdate = evt as VariableUpdate;
if (variableUpdate != null)
{
string name = variableUpdate.Action.ExpressionText;
Image rightIcon = null;
Image rightModifier = null;
if (variableUpdate.Action.Statement != null)
{
name = variableUpdate.Action.Statement.ShortShortDescription();
rightIcon = NameSpaceImages.Instance.GetImage(variableUpdate.Action.Statement.AffectedElement());
switch (variableUpdate.Action.Statement.UsageDescription())
{
case Statement.ModeEnum.Call:
rightModifier = Images.Images[CallImageIndex];
break;
case Statement.ModeEnum.In:
rightModifier = Images.Images[InImageIndex];
break;
case Statement.ModeEnum.InOut:
rightModifier = Images.Images[InOutImageIndex];
break;
case Statement.ModeEnum.Internal:
rightModifier = Images.Images[InternalImageIndex];
break;
case Statement.ModeEnum.Out:
rightModifier = Images.Images[OutImageIndex];
break;
}
}
name = GuiUtils.AdjustForDisplay(ShortName(name), _eventSize.Width - 4, BottomFont);
NameSpace nameSpace = EnclosingFinder <NameSpace> .find(variableUpdate.Action);
if (nameSpace == null)
{
retVal = new EventDisplayAttributes(Color.LightGray, new Pen(Color.Black), name, null, rightIcon,
rightModifier);
}
else
{
retVal = new EventDisplayAttributes(Color.BlanchedAlmond, new Pen(Color.Black), name, null,
rightIcon, rightModifier);
}
}
SubStepActivated subStepActivated = evt as SubStepActivated;
if (subStepActivated != null)
{
retVal = new EventDisplayAttributes(Color.LightGray, new Pen(Color.Black), "SubStep", null, null, null);
}
});
return(retVal);
}
