public void TestUpdateFunction()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Structure structure = CreateStructure(nameSpace, "S");
StructureElement el1 = CreateStructureElement(structure, "A", "Boolean");
RuleCondition condition = CreateRuleAndCondition(structure, "Cond");
Action action = CreateAction(condition, "A <- True");
Procedure procedure = CreateProcedure(structure, "P");
Parameter parameter = CreateParameter(procedure, "V", "Boolean");
RuleCondition condition2 = CreateRuleAndCondition(procedure, "Cond");
Action action2 = CreateAction(condition2, "A <- V");
Dictionary dictionary2 = CreateDictionary("TestUpdate");
dictionary2.setUpdates(dictionary.Guid);
Structure updatedStructure = structure.CreateStructureUpdate(dictionary2);
Compiler.Compile_Synchronous(true);
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(updatedStructure);
Assert.IsNull(ErrorMessage(updatedStructure));
}
public void TestStructureDereference()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Structure structure = CreateStructure(nameSpace, "Struct");
StructureElement el1 = CreateStructureElement(structure, "e1", "Boolean");
Function f = CreateFunction(nameSpace, "f", "Struct");
Variable v = CreateVariable(nameSpace, "v", "Struct");
Variable v2 = CreateVariable(nameSpace, "v2", "Boolean");
Parser parser = new Parser();
{
DerefExpression expression = parser.Expression(nameSpace, "N1.v.e1") as DerefExpression;
Assert.IsNotNull(expression);
Assert.AreEqual(3, expression.Arguments.Count);
Assert.AreEqual(v, expression.Arguments[1].Ref);
Assert.AreEqual(el1, expression.Arguments [2].Ref);
}
{
DerefExpression expression = parser.Expression(nameSpace, "N1.f().e1") as DerefExpression;
Assert.IsNotNull(expression);
Assert.AreEqual(2, expression.Arguments.Count);
Assert.AreEqual(structure, expression.Arguments [0].Ref);
Assert.AreEqual(el1, expression.Arguments [1].Ref);
}
{
DerefExpression expression = parser.Expression(nameSpace, "N1.Struct.e1") as DerefExpression;
Assert.IsNotNull(expression);
Assert.AreEqual(3, expression.Arguments.Count);
Assert.AreEqual(structure, expression.Arguments[1].Ref);
Assert.AreEqual(el1, expression.Arguments[2].Ref);
}
RuleCondition condition = CreateRuleAndCondition(nameSpace, "Test");
Action action1 = CreateAction(condition, "Struct.e1 <- True");
Action action2 = CreateAction(condition, "v2 <- Struct.e1");
Action action3 = CreateAction(condition, "f().e1 <- True");
Action action4 = CreateAction(condition, "v2 <- f().e1");
Collection collection = CreateCollection(nameSpace, "Col", "Struct", 10);
Variable v3 = CreateVariable(nameSpace, "v3", "Col");
Action action5 = CreateAction(condition, "(FIRST X IN v3).e1 <- True");
RuleCondition ruleCondition2 = CreateRuleAndCondition(structure, "Rule");
Action action6 = CreateAction(ruleCondition2, "THIS.e1 <- True");
Action action7 = CreateAction(ruleCondition2, "v2 <- THIS.e1");
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(nameSpace);
Assert.True(HasMessagePart(action1, "structure should not be used to reference an instance"));
Assert.True(HasMessagePart(action2, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action3, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action4, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action5, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action6, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action7, "structure should not be used to reference an instance"));
}
/// <summary>
/// Checks the node
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void Check(object sender, EventArgs e)
{
MarkingHistory.PerformMark(() =>
{
ModelElement modelElement = Model as ModelElement;
if (modelElement != null)
{
RuleCheckerVisitor visitor = new RuleCheckerVisitor(modelElement.Dictionary);
visitor.visit(modelElement, true);
}
});
}
public void TestEnclosing()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Structure structure = CreateStructure(nameSpace, "S");
StructureElement element = CreateStructureElement(structure, "E", "Integer");
StateMachine stateMachine = CreateStateMachine(structure, "SM");
RuleCondition condition = CreateRuleAndCondition(stateMachine, "Cond");
PreCondition preCondition = CreatePreCondition(condition, "ENCLOSING.E == 0");
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(nameSpace);
Assert.Null(ErrorMessage(preCondition));
}
public void TestApplyOnFunctionCallNoSideEffect()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Collection collection = CreateCollection(nameSpace, "Col", "Integer", 10);
Function f = CreateFunction(nameSpace, "f", "Col");
Procedure p = CreateProcedure(nameSpace, "P");
Parameter param = CreateParameter(p, "x", "Integer");
RuleCondition condition = CreateRuleAndCondition(nameSpace, "Test");
Action action1 = CreateAction(condition, "APPLY P(X) ON f()");
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(nameSpace);
Assert.Null(ErrorMessage(action1));
}
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 TestApplyOnFunctionCallWithSideEffect()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Collection collection = CreateCollection(nameSpace, "Col", "Integer", 10);
Function f = CreateFunction(nameSpace, "f", "Col");
Procedure p = CreateProcedure(nameSpace, "P");
Parameter param = CreateParameter(p, "x", "Integer");
RuleCondition condition2 = CreateRuleAndCondition(p, "Condition with side effect");
Action action2 = CreateAction(condition2, "x <- 2");
RuleCondition condition = CreateRuleAndCondition(nameSpace, "Test");
Action action1 = CreateAction(condition, "APPLY P(X) ON f()");
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(nameSpace);
Assert.False(HasMessagePart(action1, "APPLY expression whose applied statement depends on the iterator should reference a variable for the input list"));
}
public void TestApplyOnFunctionCall()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Collection collection = CreateCollection(nameSpace, "Col", "Integer", 10);
Function f = CreateFunction(nameSpace, "f", "Col");
Procedure p = CreateProcedure(nameSpace, "P");
Parameter param = CreateParameter(p, "x", "Integer");
RuleCondition condition = CreateRuleAndCondition(nameSpace, "Test");
Action action1 = CreateAction(condition, "APPLY P(X) ON f()");
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(nameSpace);
Assert.Null(ErrorMessage(action1));
}
public void TestParameterTypeName_RelativePath()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
NameSpace subNameSpace = CreateNameSpace(nameSpace, "N2");
Enum enumeration = CreateEnum(subNameSpace, "Enum");
EnumValue value1 = CreateEnumValue(enumeration, "First");
EnumValue value2 = CreateEnumValue(enumeration, "Second");
Function function = CreateFunction(nameSpace, "F1", "Boolean");
Parameter param = new Parameter();
param.setTypeName("N2.Enum");
param.setName("Value");
function.appendParameters(param);
Case cas1 = CreateCase(function, "Case 1", "True", "Value == N2.Enum.First");
Case cas2 = CreateCase(function, "Case 2", "False");
Dictionary dictionary2 = CreateDictionary("TestUpdate");
dictionary2.setUpdates(dictionary.Guid);
Function updatedFunction = function.CreateFunctionUpdate(dictionary2);
Case cas3 = (Case)updatedFunction.Cases[0];
PreCondition preCondition = (PreCondition)cas3.PreConditions[0];
preCondition.ExpressionText = "Value == N2.Enum.Second";
Compiler.Compile_Synchronous(true);
RuleCheckerVisitor ruleChecker = new RuleCheckerVisitor(dictionary2);
ruleChecker.visit(updatedFunction);
Assert.IsNull(ErrorMessage(updatedFunction));
Expression expression = new Parser().Expression(dictionary, "N1.F1(N1.N2.Enum.Second)");
IValue value = expression.GetExpressionValue(new InterpretationContext(), null);
Assert.AreEqual(System.BoolType.True, value);
}
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 TestMaxMinValuesInRange()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "NameSpace");
Range r1 = CreateRange(nameSpace, "r1", acceptor.PrecisionEnum.aIntegerPrecision, "0.5", "100");
Range r2 = CreateRange(nameSpace, "r2", acceptor.PrecisionEnum.aDoublePrecision, "0.0", "100");
Range r3 = CreateRange(nameSpace, "r3", acceptor.PrecisionEnum.aIntegerPrecision, "A", "100.0");
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(nameSpace);
Assert.True(HasMessage(r1, "Invalid min value for integer range : must be an integer"));
Assert.False(HasMessage(r1, "Invalid max value for integer range : must be an integer"));
Assert.False(HasMessage(r2, "Invalid min value for float range : must have a decimal part"));
Assert.True(HasMessage(r2, "Invalid max value for float range : must have a decimal part"));
Assert.True(HasMessage(r3, "Cannot parse min value for range"));
Assert.False(HasMessage(r3, "Cannot parse max value for range"));
}
public void TestMaxMinValuesInRange()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "NameSpace");
Range r1 = CreateRange(nameSpace, "r1", Generated.acceptor.PrecisionEnum.aIntegerPrecision, "0.5", "100");
Range r2 = CreateRange(nameSpace, "r2", Generated.acceptor.PrecisionEnum.aDoublePrecision, "0.0", "100");
Range r3 = CreateRange(nameSpace, "r3", Generated.acceptor.PrecisionEnum.aIntegerPrecision, "A", "100.0");
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(nameSpace);
Assert.True(HasMessage(r1, "Type08: Invalid min value for integer range : must be an integer"));
Assert.False(HasMessage(r1, "Type08: Invalid max value for integer range : must be an integer"));
Assert.False(HasMessage(r2, "Type09: Invalid min value for float range : must have a decimal part"));
Assert.True(HasMessage(r2, "Type09: Invalid max value for float range : must have a decimal part"));
Assert.True(HasMessage(r3, "Type10: Cannot parse min value for range"));
Assert.False(HasMessage(r3, "Type10: Cannot parse max value for range"));
}
public void TestParameterTypeInDefaultNameSpace()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace defaultNameSpace = CreateNameSpace(dictionary, "Default");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Enum enumeration = CreateEnum(defaultNameSpace, "Enum");
EnumValue value1 = CreateEnumValue(enumeration, "First");
EnumValue value2 = CreateEnumValue(enumeration, "Second");
Function function = CreateFunction(nameSpace, "F1", "Boolean");
Parameter param = new Parameter();
param.setTypeName("Enum");
param.setName("Value");
function.appendParameters(param);
Case cas1 = CreateCase(function, "Case 1", "True", "Value == Enum.First");
Case cas2 = CreateCase(function, "Case 2", "False");
Dictionary dictionary2 = CreateDictionary("TestUpdate");
dictionary2.setUpdates(dictionary.Guid);
Function updatedFunction = function.CreateFunctionUpdate(dictionary2);
Case cas3 = (Case) updatedFunction.Cases[0];
PreCondition preCondition = (PreCondition) cas3.PreConditions[0];
preCondition.ExpressionText = "Value == Enum.Second";
Compiler.Compile_Synchronous(true);
RuleCheckerVisitor ruleChecker = new RuleCheckerVisitor(dictionary2);
ruleChecker.visit(updatedFunction);
Assert.IsNull(ErrorMessage(updatedFunction));
Expression expression = Parser.Expression(dictionary, "N1.F1(Enum.Second)");
IValue value = expression.GetValue(new InterpretationContext(), null);
Assert.AreEqual(System.BoolType.True, value);
}
public void TestUpdateFunction()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Structure structure = CreateStructure(nameSpace, "S");
StructureElement el1 = CreateStructureElement(structure, "A", "Boolean");
RuleCondition condition = CreateRuleAndCondition(structure, "Cond");
Action action = CreateAction(condition, "A <- True");
Procedure procedure = CreateProcedure(structure, "P");
Parameter parameter = CreateParameter(procedure, "V", "Boolean");
RuleCondition condition2 = CreateRuleAndCondition(procedure, "Cond");
Action action2 = CreateAction(condition2, "A <- V");
Dictionary dictionary2 = CreateDictionary("TestUpdate");
dictionary2.setUpdates(dictionary.Guid);
Structure updatedStructure = structure.CreateStructureUpdate(dictionary2);
Compiler.Compile_Synchronous(true);
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(updatedStructure);
Assert.IsNull(ErrorMessage(updatedStructure));
}
/// <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);
}
public void TestStructureDereference()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Structure structure = CreateStructure (nameSpace, "Struct");
StructureElement el1 = CreateStructureElement (structure, "e1", "Boolean");
Function f = CreateFunction (nameSpace, "f", "Struct");
Variable v = CreateVariable (nameSpace, "v", "Struct");
Variable v2 = CreateVariable(nameSpace, "v2", "Boolean");
Parser parser = new Parser ();
{
DerefExpression expression = parser.Expression (nameSpace, "N1.v.e1") as DerefExpression;
Assert.IsNotNull (expression);
Assert.AreEqual(3, expression.Arguments.Count);
Assert.AreEqual(v, expression.Arguments[1].Ref);
Assert.AreEqual (el1, expression.Arguments [2].Ref);
}
{
DerefExpression expression = parser.Expression (nameSpace, "N1.f().e1") as DerefExpression;
Assert.IsNotNull (expression);
Assert.AreEqual (2, expression.Arguments.Count);
Assert.AreEqual (structure, expression.Arguments [0].Ref);
Assert.AreEqual (el1, expression.Arguments [1].Ref);
}
{
DerefExpression expression = parser.Expression(nameSpace, "N1.Struct.e1") as DerefExpression;
Assert.IsNotNull(expression);
Assert.AreEqual(3, expression.Arguments.Count);
Assert.AreEqual(structure, expression.Arguments[1].Ref);
Assert.AreEqual(el1, expression.Arguments[2].Ref);
}
RuleCondition condition = CreateRuleAndCondition (nameSpace, "Test");
Action action1 = CreateAction (condition, "Struct.e1 <- True");
Action action2 = CreateAction(condition, "v2 <- Struct.e1");
Action action3 = CreateAction(condition, "f().e1 <- True");
Action action4 = CreateAction(condition, "v2 <- f().e1");
Collection collection = CreateCollection (nameSpace, "Col", "Struct", 10);
Variable v3 = CreateVariable (nameSpace, "v3", "Col");
Action action5 = CreateAction (condition, "(FIRST X IN v3).e1 <- True");
RuleCondition ruleCondition2 = CreateRuleAndCondition(structure, "Rule");
Action action6 = CreateAction (ruleCondition2, "THIS.e1 <- True");
Action action7 = CreateAction(ruleCondition2, "v2 <- THIS.e1");
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(nameSpace);
Assert.True(HasMessagePart(action1, "structure should not be used to reference an instance"));
Assert.True(HasMessagePart(action2, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action3, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action4, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action5, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action6, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action7, "structure should not be used to reference an instance"));
}
public void TestEnclosing()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Structure structure = CreateStructure(nameSpace, "S");
StructureElement element = CreateStructureElement(structure, "E", "Integer");
StateMachine stateMachine = CreateStateMachine(structure, "SM");
RuleCondition condition = CreateRuleAndCondition(stateMachine, "Cond");
PreCondition preCondition = CreatePreCondition(condition, "ENCLOSING.E == 0");
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(nameSpace);
Assert.Null(ErrorMessage(preCondition));
}
