/// <summary>
/// Registers the errors raised during evaluation and create ModelInterpretationFailure for each one of them
/// </summary>
/// <param name="errors"></param>
private void RegisterErrors(Dictionary <Utils.ModelElement, List <ElementLog> > errors)
{
foreach (KeyValuePair <Utils.ModelElement, List <ElementLog> > pair in errors)
{
foreach (ElementLog log in pair.Value)
{
switch (log.Level)
{
case ElementLog.LevelEnum.Error:
ModelInterpretationFailure modelInterpretationFailure = new ModelInterpretationFailure(log,
pair.Key, null);
ModelElement modelElement = pair.Key as ModelElement;
if (modelElement != null)
{
modelInterpretationFailure.Explanation = modelElement.Explain;
}
EventTimeLine.AddModelEvent(modelInterpretationFailure, true);
break;
case ElementLog.LevelEnum.Warning:
break;
case ElementLog.LevelEnum.Info:
break;
}
}
}
}
/// <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>
/// Perform all functional tests defined in the .EFS file provided
/// </summary>
/// <param name="args"></param>
/// <returns>the error code of the program</returns>
private static int Main(string[] args)
{
int retVal = 0;
EfsSystem efsSystem = EfsSystem.Instance;
try
{
Console.Out.WriteLine("EFS Tester");
// Load the dictionaries provided as parameters
Util.PleaseLockFiles = false;
foreach (string arg in args)
{
Console.Out.WriteLine("Loading dictionary " + arg);
Dictionary dictionary = Util.Load(efsSystem, new Util.LoadParams(arg)
{
LockFiles = false,
Errors = null,
UpdateGuid = false,
ConvertObsolete = false
});
if (dictionary == null)
{
Console.Out.WriteLine("Cannot load dictionary " + arg);
return(-1);
}
}
// Translate the sub sequences, if required
Console.Out.WriteLine("Translating sub sequences");
foreach (Dictionary dictionary in efsSystem.Dictionaries)
{
foreach (Frame frame in dictionary.Tests)
{
foreach (SubSequence subSequence in frame.SubSequences)
{
if (subSequence.getCompleted())
{
if (dictionary.TranslationDictionary != null)
{
subSequence.Translate();
}
}
}
}
}
// Make sure everything is recompiled
Console.Out.WriteLine("Recompiling everything");
efsSystem.Compiler.Compile_Synchronous(true);
// Ensure the model is consistent
Console.Out.WriteLine("Checking model");
foreach (Dictionary dictionary in efsSystem.Dictionaries)
{
RuleCheckerVisitor checker = new RuleCheckerVisitor(dictionary);
checker.visit(dictionary);
}
// Dumps all errors found
Util.IsThereAnyError isThereAnyError = new Util.IsThereAnyError();
if (isThereAnyError.ErrorsFound.Count > 0)
{
foreach (ElementLog error in isThereAnyError.ErrorsFound)
{
Console.Out.WriteLine(error.Log);
}
return(-1);
}
{
// Perform functional test for last loaded dictionary
Dictionary dictionary = efsSystem.Dictionaries.FindLast(x => true);
Console.Out.WriteLine("Processing tests from dictionary " + dictionary.Name);
foreach (Frame frame in dictionary.Tests)
{
Console.Out.WriteLine("Executing frame " + frame.FullName);
foreach (SubSequence subSequence in frame.SubSequences)
{
Console.Out.WriteLine("Executing sub sequence " + subSequence.FullName);
if (subSequence.getCompleted())
{
Runner runner = new Runner(subSequence, false, true);
runner.RunUntilStep(null);
bool failed = false;
foreach (ModelEvent evt in runner.FailedExpectations())
{
Expect expect = evt as Expect;
if (expect != null)
{
string message = expect.Message.Replace('\n', ' ');
Console.Out.WriteLine(" failed :" + message);
failed = true;
}
else
{
ModelInterpretationFailure modelInterpretationFailure =
evt as ModelInterpretationFailure;
if (modelInterpretationFailure != null)
{
Console.Out.WriteLine(" failed : " + modelInterpretationFailure.Message);
failed = true;
}
}
}
if (failed)
{
Console.Out.WriteLine(" -> Failed");
retVal = -1;
}
else
{
Console.Out.WriteLine(" -> Success");
}
}
else
{
Console.Out.WriteLine(" -> Not executed because it is not marked as completed");
}
}
}
}
}
finally
{
Util.UnlockAllFiles();
efsSystem.Stop();
}
return(retVal);
}
/// <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);
}
