public void TestCollectionConcatenation()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Collection c1 = CreateCollection(n1, "C", "Integer", 10 );
Variable v1 = CreateVariable(n1, "V1", "C");
Variable v2 = CreateVariable(n1, "V2", "C");
Variable v3 = CreateVariable(n1, "V3", "C");
RuleCondition rc1 = CreateRuleAndCondition(n1, "Rule1");
Action a1 = CreateAction(rc1, "V1 <- [1, 2, 3] + [4, 5, 6]");
Action a2 = CreateAction(rc1, "V2 <- [] + [4, 5, 6]");
Action a3 = CreateAction(rc1, "V3 <- [1, 2, 3] + []");
// ReSharper disable once UseObjectOrCollectionInitializer
Runner runner = new Runner(false);
runner.Cycle();
{
ListValue value = v1.Value as ListValue;
Assert.IsNotNull(value);
Assert.AreEqual(6, value.Val.Count);
}
{
ListValue value = v2.Value as ListValue;
Assert.IsNotNull(value);
Assert.AreEqual(3, value.Val.Count);
}
{
ListValue value = v3.Value as ListValue;
Assert.IsNotNull(value);
Assert.AreEqual(3, value.Val.Count);
}
}
/// <summary>
/// Executes the test cases for this test sequence
/// </summary>
/// <param name="runner">The runner used to execute the test case</param>
/// <returns>the number of failed test cases</returns>
public int ExecuteAllTestCases(Runner.Runner runner)
{
int retVal = 0;
foreach (TestCase testCase in TestCases)
{
int currentFailed = runner.FailedExpectations().Count;
runner.RunUntilStep(null);
if (runner.FailedExpectations().Count > currentFailed)
{
retVal = retVal + 1;
}
}
return(retVal);
}
public void TestCollectionConcatenation()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "NameSpace");
Structure structure = CreateStructure(nameSpace, "ModelElement");
StructureElement structElem = CreateStructureElement(structure, "Value", "Boolean");
structElem.setDefault("True");
Collection collection = CreateCollection(nameSpace, "Coll", "ModelElement", 10);
collection.Type = structure;
collection.setMaxSize(3);
collection.Default = "[]";
Variable variable = CreateVariable(nameSpace, "V", "Coll");
RuleCondition ruleCondition = CreateRuleAndCondition(nameSpace, "Test");
Action action = CreateAction(ruleCondition, "V <- V + [ModelElement{Value => True}] ");
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(nameSpace);
Util.IsThereAnyError isThereAnyError = new Util.IsThereAnyError();
Assert.AreEqual(0, isThereAnyError.ErrorsFound.Count);
Assert.AreEqual("[]", variable.Value.LiteralName);
Runner runner = new Runner(false);
runner.Cycle();
Assert.AreEqual("[" + structure.DefaultValue.LiteralName + "]", variable.Value.LiteralName);
runner.Cycle();
Assert.AreEqual("[" + structure.DefaultValue.LiteralName + ", " + structure.DefaultValue.LiteralName + "]", variable.Value.LiteralName);
runner.Cycle();
Assert.AreEqual("[" + structure.DefaultValue.LiteralName + ", " + structure.DefaultValue.LiteralName + ", " + structure.DefaultValue.LiteralName + "]", variable.Value.LiteralName);
// In this case, the new collection cannot be placed in the variable
runner.Cycle();
Assert.AreEqual(1, action.Messages.Count);
Assert.AreEqual(ElementLog.LevelEnum.Error, action.Messages[0].Level);
}
public void TestUncacheFunctionBasedOnInnerFunctionCall()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Collection c = CreateCollection(n1, "C", "Integer", 10);
Variable a = CreateVariable(n1, "a", "C");
a.setDefaultValue("[1]");
Variable b = CreateVariable(n1, "b", "C");
b.setDefaultValue("[10]");
Function f = CreateFunction(n1, "f", "C");
Case always_f = CreateCase(f, "Always", "g() + h()");
Function g = CreateFunction(n1, "g", "C");
Case always_g = CreateCase(g, "Always", "a");
Function h = CreateFunction(n1, "h", "C");
Case always_h = CreateCase(h, "Always", "b");
RuleCondition updateGlobalVariables = CreateRuleAndCondition(n1, "Update Global variables");
Action act1 = CreateAction(updateGlobalVariables, "a <- a + [2]");
Action act2 = CreateAction(updateGlobalVariables, "b <- b + [20]");
Compiler.Compile_Synchronous(true);
Expression expression = new Parser().Expression(test, "N1.f()");
ListValue value = expression.GetExpressionValue(new InterpretationContext(), null) as ListValue;
Assert.IsNotNull(value);
Assert.AreEqual(2, value.Val.Count);
// ReSharper disable once UseObjectOrCollectionInitializer
Runner runner = new Runner(false);
runner.CheckForCompatibleChanges = true;
runner.Cycle();
value = expression.GetExpressionValue(new InterpretationContext(), null) as ListValue;
Assert.IsNotNull(value);
Assert.AreEqual(4, value.Val.Count);
}
public void TestRefactorStructureName()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Collection collection = CreateCollection(n1, "Col", "Integer", 10);
Variable v = CreateVariable(n1, "V", "Col");
v.setDefaultValue("[]");
RuleCondition rc1 = CreateRuleAndCondition(n1, "Rule1");
Action a1 = CreateAction(rc1, "INSERT 1 IN V");
RuleCondition rc2 = CreateRuleAndCondition(n1, "Rule2");
Action a2 = CreateAction(rc2, "INSERT 2 IN V");
// ReSharper disable once UseObjectOrCollectionInitializer
Runner runner = new Runner(false);
runner.CheckForCompatibleChanges = true;
runner.Cycle();
ListValue listValue = v.Value as ListValue;
Assert.IsNotNull(listValue);
Assert.AreEqual(2, listValue.Val.Count);
Assert.AreEqual(0, a1.Messages.Count);
Assert.AreEqual(0, a2.Messages.Count);
}
/// <summary>
/// Apply all changes
/// </summary>
/// <param name="runner"></param>
public void Apply(Runner runner)
{
foreach (Change change in Changes)
{
change.Apply(runner);
}
}
/// <summary>
/// Applies the change if it has not yet been applied
/// </summary>
/// <param name="runner"></param>
public void Apply(Runner runner)
{
if (!Applied)
{
if (runner.LogEvents)
{
Log.Info(Variable.FullName + "<-" + NewValue.LiteralName);
}
ChangeVariableValue(NewValue);
Applied = true;
}
}
/// <summary>
/// Adds a change to the list of changes
/// </summary>
/// <param name="change">The change to add</param>
/// <param name="apply">Indicates whether the change should be applied immediately</param>
/// <param name="runner"></param>
public void Add(Change change, bool apply, Runner runner)
{
Changes.Add(change);
if (apply)
{
// BUG: This is the case for procedure calls.
// In this case, computing the next changes induced by the procedure must be based on this changes.
// However, this contradicts a invariant : the state of the system does not change as long as all changes have not been computed
// To fix this, changes should be unapplied at the end of the procedure call change evaluation to be applied back
// during the activation application.
change.Apply(runner);
}
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
int index = context.LocalScope.PushContext();
context.LocalScope.setVariable(IteratorVariable);
IVariable variable = ListExpression.GetVariable(context);
if (variable != null)
{
// HacK : ensure that the value is a correct rigth side
// and keep the result of the right side operation
ListValue listValue = variable.Value.RightSide(variable, false, false) as ListValue;
variable.Value = listValue;
if (listValue != null)
{
ListValue newListValue = new ListValue(listValue);
int i = 0;
foreach (IValue current in newListValue.Val)
{
IteratorVariable.Value = current;
if (conditionSatisfied(context, explanation))
{
break;
}
i += 1;
}
if (i < newListValue.Val.Count)
{
IValue value = Value.GetValue(context, explanation);
if (value != null)
{
newListValue.Val[i] = value;
Change change = new Change(variable, variable.Value, newListValue);
changes.Add(change, apply, runner);
ExplanationPart.CreateSubExplanation(explanation, Root, change);
}
else
{
Root.AddError("Cannot find value for " + Value.ToString());
}
}
else
{
Root.AddError("Cannot find value in " + ListExpression.ToString() + " which satisfies " +
Condition.ToString());
}
}
else
{
Root.AddError("Variable " + ListExpression.ToString() + " does not contain a list value");
}
}
else
{
Root.AddError("Cannot find variable for " + ListExpression.ToString());
}
context.LocalScope.PopContext(index);
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
IVariable var = VariableIdentification.GetVariable(context);
if (var != null)
{
IValue value = Expression.GetExpressionValue(context, explanation);
if (value != null)
{
value = value.RightSide(var, true, true);
}
Range range = var.Type as Range;
if (range != null && range.convert(value) == null)
{
AddError("Value " + value + " is outside range");
}
else
{
Change change = new Change(var, var.Value, value);
changes.Add(change, apply, runner);
ExplanationPart.CreateSubExplanation(explanation, Root, change);
}
}
else
{
AddError("Cannot find variable " + VariableIdentification);
}
}
/// <summary>
/// Evaluates the rule and its sub rules
/// </summary>
/// <param name="runner"></param>
/// <param name="priority">the priority level : a rule can be activated only if its priority level == priority</param>
/// <param name="instance">The instance on which the rule must be evaluated</param>
/// <param name="ruleConditions">the rule conditions to be activated</param>
/// <param name="explanation">The explanation part to be filled</param>
/// <param name="runner"></param>
/// <returns>the number of actions that were activated during this evaluation</returns>
public bool Evaluate(Runner runner, acceptor.RulePriority priority, IModelElement instance,
HashSet<Runner.Activation> activations, ExplanationPart explanation)
{
bool retVal = false;
ExplanationPart conditionExplanation = ExplanationPart.CreateSubExplanation(explanation, this);
InterpretationContext context = new InterpretationContext(instance);
retVal = EvaluatePreConditions(context, conditionExplanation, runner);
if (retVal)
{
if (conditionExplanation != null)
{
conditionExplanation.Message = "Condition " + Name + " satisfied";
}
foreach (Rule subRule in SubRules)
{
subRule.Evaluate(runner, priority, instance, activations, conditionExplanation);
}
if (EnclosingRule.getPriority() == priority)
{
activations.Add(new Runner.Activation(this, instance, conditionExplanation));
}
}
else
{
if (conditionExplanation != null)
{
conditionExplanation.Message = "Condition " + Name + " not satisfied";
}
}
return retVal;
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
// Explain what happens in this statement
explanation = ExplanationPart.CreateSubExplanation(explanation, this);
// Evaluate the list on which the APPLY statement shall be evaluated
ListValue listValue = null;
if (SideEffectOnVariable)
{
// If the apply statement has side effect, copy the corresponding variable
// to be able to roll back the changes (in case of execution step back for instance)
IVariable variable = ListExpression.GetVariable(context);
if (variable != null)
{
if (variable.Value != EfsSystem.Instance.EmptyValue)
{
// HacK : ensure that the value is a correct rigth side
// and keep the result of the right side operation
listValue = variable.Value.RightSide(variable, false, false) as ListValue;
variable.Value = listValue;
}
}
}
else
{
IValue value = ListExpression.GetValue(context, explanation);
if (value != null)
{
listValue = value as ListValue;
}
}
if (listValue != null)
{
ExplanationPart.CreateSubExplanation(explanation, "Input data = ", listValue);
int token = context.LocalScope.PushContext();
context.LocalScope.SetVariable(IteratorVariable);
bool elementFound = false;
bool matchingElementFound = false;
foreach (IValue value in listValue.Val)
{
if (value != EfsSystem.Instance.EmptyValue)
{
// All elements should always be != from EmptyValue
elementFound = true;
IteratorVariable.Value = value;
if (ConditionSatisfied(context, explanation))
{
matchingElementFound = true;
AppliedStatement.GetChanges(context, changes, explanation, apply, runner);
}
}
}
if (!elementFound)
{
ExplanationPart.CreateSubExplanation(explanation, "Empty collection");
}
else if (!matchingElementFound)
{
ExplanationPart.CreateSubExplanation(explanation, "No matching element found");
}
context.LocalScope.PopContext(token);
}
else
{
ExplanationPart.CreateSubExplanation(explanation,
"List expression cannot be evaluated as a valid list value");
}
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
IVariable variable = ListExpression.GetVariable(context);
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
changes.Add(new InsertInListChange(context, this, variable, explanation), apply, runner);
}
/// <summary>
/// Creates a list of changes to be applied on the system
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list of changes to be updated</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
/// <returns>The list to fill with the changes</returns>
public virtual void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
if (!DeActivated)
{
long start = Environment.TickCount;
try
{
if (Statement != null)
{
Statement.GetChanges(context, changes, explanation, apply, runner);
}
else
{
AddError("Invalid actions statement");
}
}
catch (Exception e)
{
AddException(e);
}
long stop = Environment.TickCount;
long span = (stop - start);
if (RuleCondition != null && RuleCondition.EnclosingRule != null)
{
// Rule execution execution time (as opposed to guard evaluation)
RuleCondition.EnclosingRule.ExecutionTimeInMilli += span;
RuleCondition.EnclosingRule.ExecutionCount += 1;
}
}
}
/// <summary>
/// Evaluates the rule and its sub rules
/// </summary>
/// <param name="runner"></param>
/// <param name="priority">the priority level : a rule can be activated only if its priority level == priority</param>
/// <param name="instance">The instance on which the rule must be evaluated</param>
/// <param name="ruleConditions">the rule conditions to be activated</param>
/// <param name="explanation">The explanation part to be filled</param>
/// <param name="runner"></param>
/// <returns>the number of actions that were activated during this evaluation</returns>
public bool Evaluate(Runner runner, acceptor.RulePriority priority, IModelElement instance,
HashSet<Runner.Activation> activations, ExplanationPart explanation)
{
bool retVal = false;
if (UpdatedBy.Count == 0 && !IsRemoved && ActivationPriorities.Contains(priority))
{
long start = Environment.TickCount;
foreach (RuleCondition ruleCondition in RuleConditions)
{
retVal = ruleCondition.Evaluate(runner, priority, instance, activations, explanation);
if (retVal)
{
break;
}
}
// Guard evaluation execution time
long stop = Environment.TickCount;
long span = (stop - start);
ExecutionTimeInMilli += span;
}
return retVal;
}
public void TestSubRulesPriority()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Variable v1 = CreateVariable(n1, "V", "Integer");
v1.setDefaultValue("0");
Variable v2 = CreateVariable(n1, "V2", "Integer");
v2.setDefaultValue("0");
// Priority is Processing
RuleCondition rc1 = CreateRuleAndCondition(n1, "Rule1");
Action a1 = CreateAction(rc1, "V2 <- V2 + 1");
// Priority is Update out
RuleCondition rc2 = CreateRuleAndCondition(rc1, "Rule2");
rc2.EnclosingRule.setPriority(acceptor.RulePriority.aUpdateOUT);
Action a2 = CreateAction(rc2, "V <- V + 1");
// ReSharper disable once UseObjectOrCollectionInitializer
Runner runner = new Runner(false);
runner.Cycle();
IntValue value = v1.Value as IntValue;
Assert.IsNotNull(value);
Assert.AreEqual(1, value.Val);
value = v2.Value as IntValue;
Assert.IsNotNull(value);
Assert.AreEqual(1, value.Val);
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
IVariable variable = ListExpression.GetVariable(context);
if (variable != null)
{
// HacK : ensure that the value is a correct rigth side
// and keep the result of the right side operation
ListValue listValue = variable.Value.RightSide(variable, false, false) as ListValue;
variable.Value = listValue;
if (listValue != null)
{
IValue value = Value.GetValue(context, explanation);
if (value != null)
{
if (!listValue.Val.Contains(value))
{
ListValue newListValue = new ListValue(listValue);
int index = newListValue.Val.IndexOf(EFSSystem.EmptyValue);
if (index >= 0)
{
newListValue.Val[index] = value;
}
else
{
// List is full, try to remove an element before inserting the new element
if (ReplaceElement != null)
{
IValue removeValue = ReplaceElement.GetValue(context, explanation);
index = newListValue.Val.IndexOf(removeValue);
if (index >= 0)
{
newListValue.Val[index] = value.RightSide(variable, true, true);
}
else
{
Root.AddError("Cannot remove replacing element " + removeValue.Name);
}
}
else
{
Root.AddError("Cannot add new element in list value : list is full");
}
}
Change change = new Change(variable, variable.Value, newListValue);
changes.Add(change, apply, runner);
ExplanationPart.CreateSubExplanation(explanation, Root, change);
}
else
{
AddError("Value " + value.LiteralName + " already present in list. It has not been added");
}
}
else
{
Root.AddError("Cannot find value for " + Value.ToString());
}
}
else
{
Root.AddError("Variable " + ListExpression.ToString() + " does not contain a list value");
}
}
else
{
Root.AddError("Cannot find variable for " + ListExpression.ToString());
}
}
/// <summary>
/// Applies the change if it has not yet been applied
/// </summary>
/// <param name="runner"></param>
public void Apply(Runner runner)
{
if (!Applied)
{
ChangeVariableValue(NewValue);
Applied = true;
}
}
/// <summary>
/// Creates a section for a given test case
/// </summary>
/// <param name="runner">The runner to be used to execute the tests</param>
/// <param name="aTestCase">Test case to be displayed</param>
/// <param name="aReportConfig">The report configuration containing display details</param>
/// <param name="activatedRuleConditions">The list that will contain the rules activated by this test case</param>
/// <param name="createPdf">Indicates if the information about this sub-sequence has to be added to the pdf</param>
public void CreateTestCaseSection(Runner runner, TestCase aTestCase, TestsCoverageReportHandler aReportConfig,
HashSet<RuleCondition> activatedRuleConditions, bool createPdf)
{
string title = "Test case " + aTestCase.Name;
if (createPdf)
{
AddSubParagraph(title);
if (aTestCase.Requirements.Count > 0)
{
AddSubParagraph(title + ": verified requirements:");
foreach (ReqRef reqRef in aTestCase.Requirements)
{
string text = "Requirement " + reqRef.Name;
if (!Utils.Utils.isEmpty(reqRef.Comment))
{
text = text + " : " + reqRef.Comment;
}
AddListItem(text);
}
CloseSubParagraph();
}
}
runner.RunUntilStep(null);
activatedRuleConditions.UnionWith(runner.EventTimeLine.GetActivatedRules());
if (createPdf)
{
if (aReportConfig.AddSteps)
{
foreach (Step step in aTestCase.Steps)
{
if (step.SubSteps.Count > 0)
{
SubStep firstSubStep = step.SubSteps[0] as SubStep;
SubStep lastSubStep = step.SubSteps[step.SubSteps.Count - 1] as SubStep;
double start = runner.EventTimeLine.GetSubStepActivationTime(firstSubStep);
double end = runner.EventTimeLine.GetNextSubStepActivationTime(lastSubStep);
List<RuleCondition> activatedRules = runner.EventTimeLine.GetActivatedRulesInRange(start,
end);
CreateStepSection(step, activatedRules, aReportConfig);
}
}
}
CreateActivatedRulesSection(title,
runner.EventTimeLine.GetActivatedRules(),
aReportConfig.Dictionary.ImplementedRules,
aReportConfig.AddActivatedRulesInTestCases);
CloseSubParagraph();
}
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
if (Call != null)
{
InterpretationContext ctxt = getContext(context, explanation);
Procedure procedure = Call.getProcedure(ctxt, explanation);
if (procedure != null)
{
ctxt.HasSideEffects = true;
// If the procedure has been defined in a structure,
// ensure that it is applied to an instance of that structure
Structure structure = procedure.Enclosing as Structure;
if (structure != null)
{
ITypedElement current = ctxt.Instance as ITypedElement;
while (current != null)
{
if (current.Type != structure)
{
IEnclosed enclosed = current as IEnclosed;
if (enclosed != null)
{
current = enclosed.Enclosing as ITypedElement;
}
else
{
current = null;
}
}
else
{
ctxt.Instance = current;
current = null;
}
}
}
ExplanationPart part = ExplanationPart.CreateSubExplanation(explanation, procedure);
if (ctxt.Instance is IVariable)
{
ExplanationPart.SetNamable(part, ctxt.Instance);
ExplanationPart instanceExplanation = ExplanationPart.CreateSubExplanation(part, "instance = ");
ExplanationPart.SetNamable(instanceExplanation, ctxt.Instance);
}
int token = ctxt.LocalScope.PushContext();
foreach (
KeyValuePair<Actual, IValue> pair in Call.AssignParameterValues(context, procedure, true, part))
{
ctxt.LocalScope.setVariable(pair.Key, pair.Value);
}
foreach (Rule rule in procedure.Rules)
{
ApplyRule(rule, changes, ctxt, part, runner);
}
ctxt.LocalScope.PopContext(token);
}
else
{
AddError("Cannot determine the called procedure for " + ToString());
}
}
else
{
AddError("Expression " + ToString() + " is not a valid procedure call");
}
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
// Explain what happens in this statement
explanation = ExplanationPart.CreateSubExplanation(explanation, this);
IVariable variable = ListExpression.GetVariable(context);
if (variable != null)
{
// HacK : ensure that the value is a correct rigth side
// and keep the result of the right side operation
ListValue listValue = variable.Value.RightSide(variable, false, false) as ListValue;
variable.Value = listValue;
if (listValue != null)
{
// Provide the state of the list before removing elements from it
ExplanationPart.CreateSubExplanation(explanation, "Input data = ", listValue);
ListValue newListValue = new ListValue(listValue.CollectionType, new List<IValue>());
int token = context.LocalScope.PushContext();
context.LocalScope.SetVariable(IteratorVariable);
int index = 0;
if (Position == PositionEnum.Last)
{
index = listValue.Val.Count - 1;
}
// Remove the element while required to do so
while (index >= 0 && index < listValue.Val.Count)
{
IValue value = listValue.Val[index];
index = NextIndex(index);
IteratorVariable.Value = value;
if (ConditionSatisfied(context, explanation))
{
if (Position != PositionEnum.All)
{
break;
}
}
else
{
InsertInResult(newListValue, value);
}
}
// Complete the list
while (index >= 0 && index < listValue.Val.Count)
{
IValue value = listValue.Val[index];
InsertInResult(newListValue, value);
index = NextIndex(index);
}
Change change = new Change(variable, variable.Value, newListValue);
changes.Add(change, apply, runner);
ExplanationPart.CreateSubExplanation(explanation, Root, change);
context.LocalScope.PopContext(token);
}
}
}
/// <summary>
/// Applies a rule defined in a procedure
/// </summary>
/// <param name="rule"></param>
/// <param name="changes"></param>
/// <param name="ctxt"></param>
/// <param name="explanation"></param>
/// <param name="runner"></param>
private void ApplyRule(Rule rule, ChangeList changes, InterpretationContext ctxt, ExplanationPart explanation,
Runner runner)
{
foreach (RuleCondition condition in rule.RuleConditions)
{
ExplanationPart conditionExplanation = ExplanationPart.CreateSubExplanation(explanation, condition);
if (condition.EvaluatePreConditions(ctxt, conditionExplanation, runner))
{
ExplanationPart.SetNamable(conditionExplanation, EFSSystem.BoolType.True);
foreach (Action action in condition.Actions)
{
action.GetChanges(ctxt, changes, conditionExplanation, true, runner);
}
foreach (Rule subRule in condition.SubRules)
{
ApplyRule(subRule, changes, ctxt, conditionExplanation, runner);
}
break;
}
else
{
ExplanationPart.SetNamable(conditionExplanation, EFSSystem.BoolType.False);
}
}
}
public void TestUncacheFunctionOfFunction()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Variable v = CreateVariable(n1, "Var", "Boolean");
v.setDefaultValue("True");
Function F1 = CreateFunction(n1, "FunOfVar", "Integer");
Case cas1_1 = CreateCase(F1, "Var is true", "1", "Var");
Case cas1_2 = CreateCase(F1, "Var is false", "2");
Function F2 = CreateFunction(n1, "FunOfFun", "Boolean");
Case cas2_1 = CreateCase(F2, "Value", "FunOfVar() == 2");
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Action a = CreateAction(rc, "Var <- False");
Compiler.Compile_Synchronous(true);
Expression expression = new Parser().Expression(test, "N1.FunOfFun()");
IValue value = expression.GetExpressionValue(new InterpretationContext(), null);
Assert.AreEqual(value, System.BoolType.False);
// ReSharper disable once UseObjectOrCollectionInitializer
Runner runner = new Runner(false);
runner.CheckForCompatibleChanges = true;
runner.Cycle();
value = expression.GetExpressionValue(new InterpretationContext(), null);
Assert.AreEqual(value, System.BoolType.True);
}
/// <summary>
/// Provides the actual value for the preconditions
/// </summary>
/// <param name="context">The context on which the precondition must be evaluated</param>
/// <param name="explanation">The explanation part to fill, if any</param>
/// <param name="log">indicates that this should be logged</param>
/// <param name="runner"></param>
/// <returns></returns>
public bool EvaluatePreConditions(InterpretationContext context, ExplanationPart explanation, Runner runner)
{
bool retVal = true;
foreach (PreCondition preCondition in PreConditions)
{
try
{
ExplanationPart subExplanation = ExplanationPart.CreateNamedSubExplanation(explanation,
"PreCondition ", preCondition);
BoolValue value = preCondition.Expression.GetExpressionValue(context, subExplanation) as BoolValue;
ExplanationPart.SetNamable(subExplanation, value);
if (value != null)
{
retVal = retVal && value.Val;
}
else
{
retVal = false;
// TODO : Handle Error
}
if (!retVal)
{
break;
}
}
catch (Exception e)
{
preCondition.Expression.AddErrorAndExplain(e.Message, explanation);
retVal = false;
break;
}
}
return retVal;
}
/// <summary>
/// Applies the change
/// </summary>
/// <param name="runner"></param>
public override void Apply(Runner runner)
{
if (! Applied)
{
// Compute the new value when applying the change (instead of when creating the change)
Change change = Statement.GetChange(Context, Variable, Explanation, true, runner);
PreviousValue = change.PreviousValue;
NewValue = change.NewValue;
base.Apply(runner);
}
}
/// <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.CheckRules();
}
// 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())
{
if(subSequence.Name.Contains("S050"))
System.Diagnostics.Debugger.Break();
Runner runner = new Runner(subSequence, false, true, 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;
}
public void TestStabilize()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Variable v1 = CreateVariable(n1, "V", "Double");
v1.setDefaultValue("0.0");
RuleCondition rc1 = CreateRuleAndCondition(n1, "Rule1");
Action a1 = CreateAction(rc1, "V <- STABILIZE (LAST v IN VALUES) / 2.0 INITIAL_VALUE 100.0 STOP_CONDITION PREVIOUS - CURRENT < 10.0 ");
// ReSharper disable once UseObjectOrCollectionInitializer
Runner runner = new Runner(false);
runner.Cycle();
DoubleValue value = v1.Value as DoubleValue;
Assert.IsNotNull(value);
Assert.AreEqual(6.25, value.Val);
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
// Explain what happens in this statement
explanation = ExplanationPart.CreateSubExplanation(explanation, this);
IVariable variable = ListExpression.GetVariable(context);
if (variable != null)
{
// HacK : ensure that the value is a correct rigth side
// and keep the result of the right side operation
ListValue listValue = variable.Value.RightSide(variable, false, false) as ListValue;
variable.Value = listValue;
if (listValue != null)
{
ExplanationPart.CreateSubExplanation(explanation, "Input data = ", listValue);
IValue value = Value.GetExpressionValue(context, explanation);
if (value != null)
{
if (!listValue.Val.Contains(value))
{
ListValue newListValue = new ListValue(listValue);
int index = newListValue.Val.IndexOf(EfsSystem.Instance.EmptyValue);
if (index >= 0)
{
ExplanationPart.CreateSubExplanation(explanation, "Inserting", value);
newListValue.Val[index] = value;
}
else
{
// List is full, try to remove an element before inserting the new element
if (ReplaceElement != null)
{
IValue removeValue = ReplaceElement.GetExpressionValue(context, explanation);
ExplanationPart.CreateSubExplanation(explanation, "Replaced element", removeValue);
index = newListValue.Val.IndexOf(removeValue);
if (index >= 0)
{
ExplanationPart.CreateSubExplanation(explanation, "Replacing", value);
newListValue.Val[index] = value.RightSide(variable, true, true);
}
else
{
Root.AddError("Cannot remove replacing element " + removeValue.Name);
}
}
else
{
Root.AddError("Cannot add new element in list value : list is full");
}
}
Change change = new Change(variable, variable.Value, newListValue);
changes.Add(change, apply, runner);
ExplanationPart.CreateSubExplanation(explanation, Root, change);
}
else
{
ExplanationPart.CreateSubExplanation(explanation, "NOT added : Already present in collection", value);
}
}
else
{
Root.AddError("Cannot find value for " + Value);
}
}
else
{
Root.AddError("Variable " + ListExpression + " does not contain a list value");
}
}
else
{
Root.AddError("Cannot find variable for " + ListExpression);
}
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
// Explain what happens in this statement
explanation = ExplanationPart.CreateSubExplanation(explanation, this);
IVariable variable = ListExpression.GetVariable(context);
if (variable != null)
{
if (variable.Value != EfsSystem.Instance.EmptyValue)
{
// HacK : ensure that the value is a correct rigth side
// and keep the result of the right side operation
ListValue listValue = variable.Value.RightSide(variable, false, false) as ListValue;
variable.Value = listValue;
ExplanationPart.CreateSubExplanation(explanation, "Input data = ", listValue);
if (listValue != null)
{
int token = context.LocalScope.PushContext();
context.LocalScope.SetVariable(IteratorVariable);
bool elementFound = false;
bool matchingElementFound = false;
foreach (IValue value in listValue.Val)
{
if (value != EfsSystem.Instance.EmptyValue)
{
elementFound = true;
IteratorVariable.Value = value;
if (ConditionSatisfied(context, explanation))
{
matchingElementFound = true;
AppliedStatement.GetChanges(context, changes, explanation, apply, runner);
}
}
}
if (!elementFound)
{
ExplanationPart.CreateSubExplanation(explanation, "Empty collection");
}
else if (!matchingElementFound)
{
ExplanationPart.CreateSubExplanation(explanation, "No matching element found");
}
context.LocalScope.PopContext(token);
}
else
{
Root.AddError("List expression does not evaluate to a list value");
}
}
}
else
{
Root.AddError("Cannot find variable for " + ListExpression);
}
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The changes performed by this statement</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public abstract void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner);
/// <summary>
/// Roll back all changes in the list
/// </summary>
/// <param name="runner"></param>
public void RollBack(Runner runner)
{
for (int i = Changes.Count - 1; i >= 0; i--)
{
Changes[i].RollBack(runner);
}
}
