Separated tests in multiple files for better accessibility.

Fixed many bugs in the declaration visitor.

cp-dsl/generator/visitors/declaration_visitor.py

@@ -25,7 +25,7 @@ from antlr4 import ParserRuleContext, TerminalNode
 # user relative imports
 from model.symbols import Scope, T, P
 from model.declaration_model import DeclarationModel, Parameter, ParameterGroup, Feature, FeatureGroup, EKind
-from model.type_system import GenericEnumeralType, EnumeralType, InternalEnumeralType, Enumeral, RangeType, ArrayType, Dimension, BaseType, base_types
+from model.type_system import EnumeralType, InlineEnumeralType, Enumeral, RangeType, ArrayType, Dimension, BaseType, base_types
 from model.unit_model import Unit, UnitPrefix, UnitKind, UnitSpecification, SIUnit, CustomUnit, DivisionUnit, ExponentUnit
 from common.logger import GeneratorLogger
 from model.arithmetic_model import ArithmeticExpression, MultiplicationExpression, IntValue, FloatValue, StringValue, EMultiplicationOperator, EAdditionOperator
@@ -113,22 +113,22 @@ class GeneratorDeclarationVisitor(DeclarationVisitor, Generic[T]):
             enum_type = EnumeralType(enum_name)
             self._declaration_model.add_new_type(enum_type)
 
-        for i in ctx.enumeral():
+        for enumeral in ctx.values:
             # enum_list representation: [(id, value),...]
-            enum_item = self.visitEnumeral(i)
+            enum_item = self.visitEnumeral(enumeral)
             if enum_item.value == -1:
                 enum_item.value = self.find_next_enum_number(enum_type._enumerals)
             if self.check_enumeral_name(enum_item, enum_type._enumerals):
-                self._logger.strict(ctx, f"Enumeral {enum_item[0]} already exists in enumeration {enum_name}")
+                self._logger.strict(ctx, f"Enumeral {enum_item} already exists in enumeration {enum_name}")
             else:
                 enum_type._enumerals[enum_item.name] = enum_item
 
         return enum_type
 
     def visitInlineEnumerationType(self, ctx: DeclarationParser.InlineEnumerationTypeContext):
-        enum_type = InternalEnumeralType()
+        enum_type = InlineEnumeralType()
 
-        for i in ctx.enumeral():
+        for i in ctx.values:
             # enum_list representation: [(id, value),...]
             enum_item = self.visitEnumeral(i)
             if enum_item.value == -1:
@@ -398,14 +398,15 @@ class GeneratorDeclarationVisitor(DeclarationVisitor, Generic[T]):
         depth = len(ctx.elements)
         scope = self._scope
         if depth > 1:
-            for i in range(1,depth-1):
+            for i in range(1,depth):
                 scope = scope.parent
 
         # check whether it is a parameter
         parameter_level = 0
         param = True
-        for i in range(0,depth-1):
-            scope = scope.resolve_symbol(ctx.elements[i])
+        for i in range(0,depth):
+            scope = scope.resolve_symbol(ctx.elements[i].text)
+
             if scope is None:
                 parameter_level = i
                 param = False
@@ -416,26 +417,30 @@ class GeneratorDeclarationVisitor(DeclarationVisitor, Generic[T]):
 
         # check whether it is an enumeration
         if depth == 2: # Can be an enumeration
-            type = self._declaration_model._types.get(ctx.elements[0])
-            if issubclass(type, GenericEnumeralType):
-                enumeral = type._enumerals.get(ctx.elements[1], None)
+            data_type = self._declaration_model._types.get(ctx.elements[0].text)
+            if isinstance(data_type, EnumeralType):
+                enumeral = data_type._enumerals.get(ctx.elements[1].text, None)
                 if enumeral is None:
-                    self._logger.strict(ctx, f"Symbol {self.print_symbol(ctx.element,2)} does not refer to an enumeral")
+                    self._logger.strict(ctx, f"Symbol {self.print_symbol(ctx.elements, 2)} does not refer to an enumeral")
                     return None
                 else:
-                self._logger.strict(ctx, f"Symbol {self.print_symbol(ctx.element,1)} does not refer to an enumeration type")
+                    return enumeral
+            else:
+                self._logger.strict(ctx, f"Symbol {self.print_symbol(ctx.elements, 1)} does not refer to an enumeration type")
                 return None
 
         # check whether it is an enumeration inferred by parameter type
         if isinstance(self._type_scope, Parameter):
-            type = self._type_scope
-            if issubclass(type, GenericEnumeralType):
-                enumeral = type._enumerals.get(ctx.elements[0], None)
+            data_type = self._type_scope
+            if isinstance(data_type, EnumeralType, InlineEnumeralType):
+                enumeral = data_type._enumerals.get(ctx.elements[0].text, None)
                 if enumeral is None:
-                    self._logger.strict(ctx, f"Symbol {self.print_symbol(ctx.element,2)} does not refer to an enumeral")
+                    self._logger.strict(ctx, f"Symbol {self.print_symbol(ctx.elements, 2)} does not refer to an enumeral")
                     return None
                 else:
-                self._logger.strict(ctx, f"Symbol {self.print_symbol(ctx.element,1)} does not refer to an enumeration type")
+                    return enumeral
+            else:
+                self._logger.strict(ctx, f"Symbol {self.print_symbol(ctx.elements, 1)} does not refer to an enumeration type")
                 return None
 
         # Strange cases
@@ -444,11 +449,12 @@ class GeneratorDeclarationVisitor(DeclarationVisitor, Generic[T]):
 
     def print_symbol(self, elements:list, level:int):
         result = ""
-        for i in range(0,level-1):
+        for i in range(0,level):
+            name = elements[i].text
             if result == "":
-                result = f"{elements[i]}"
+                result = f"{name}"
             else:
-                result = f"{result}.{elements[i]}"
+                result = f"{result}.{name}"
         return result
 
     ##################################

cp-dsl/model/symbols.py

@@ -515,12 +515,7 @@ class ScopedSymbol(Symbol, Scope):
         :return: the first symbol with a given name, in the order of appearance in this scope or any of the parent
         scopes (conditionally) or any scope included.
         """
-        for child in self.children():
-            if child.name == name:
-
-
-if not t or (not type_only and isinstance(child, t)) or (type_only and isinstance(child,                 if not t or (not type_only and isinstance(child, t)) or (type_only and )                    return child
-
+        # TODO this is broken
         # Nothing found locally. the parent continues.
         if not local_only:
             # Call parent scope

cp-dsl/model/type_system.py

@@ -62,16 +62,14 @@ class GenericEnumeralType(Type):
     def __init__(self) -> None:
         self._enumerals = {}
 
-class InternalEnumeralType(GenericEnumeralType):
+class InlineEnumeralType(GenericEnumeralType):
     pass
 
 class EnumeralType(GenericEnumeralType, NamedType):
 
-    def __init__(self, name: str = "", enumerals={}):
+    def __init__(self, name: str = ""):
         super().__init__()
         self.name = name
-        self._enumerals = enumerals
-
 
 class RangeType(NamedType):
     '''

cp-dsl/test/generator/visitors/declaration_visitor_arithmetic_test.py

@@ -15,9 +15,8 @@
 __author__ = "reiner"
 
 import unittest
-from generator.visitors.declaration_visitor import GeneratorDeclarationVisitor
 from model.declaration_model import DeclarationModel, ParameterGroup, Parameter, FeatureGroup, Feature
-from model.type_system import EnumeralType, Enumeral, RangeType, BaseType, ArrayType, Dimension, InternalEnumeralType, Enumeral
+from model.type_system import EnumeralType, Enumeral, RangeType, BaseType, ArrayType, Dimension, InlineEnumeralType, Enumeral
 from model.unit_model import UnitSpecification, UnitKind, UnitPrefix, SIUnit, CustomUnit, DivisionUnit, ExponentUnit
 from model.arithmetic_model import IntValue, StringValue, FloatValue, ArithmeticExpression, MultiplicationExpression, EMultiplicationOperator, EAdditionOperator
 from antlr4 import InputStream, CommonTokenStream
@@ -31,14 +30,9 @@ from dcllspserver.gen.python.Declaration.DeclarationParser import DeclarationPar
 from common.logger import GeneratorLogger
 from common.configuration import CompileFlags
 
-class TestStream(InputStream):
+from test_utils import TestGeneratorDeclarationVisitorBase
 
-    fileName = "test"
-
-    def __init__(self, data: str) -> None:
-        super().__init__(data)
-
-class TestGeneratorDeclarationVisitor(unittest.TestCase):
+class TestGeneratorDeclarationVisitor(TestGeneratorDeclarationVisitorBase):
 
     logger = GeneratorLogger(CompileFlags.STRICT)
 
@@ -216,7 +210,6 @@ class TestGeneratorDeclarationVisitor(unittest.TestCase):
         self.assertIsInstance(result.value, int, "Wrong value type")
         self.assertEqual(result.value, 10, "Incorrect value")
 
-
     def test_visitDoubleValue(self):
         value = DeclarationParser.DoubleValueContext(parent=None, parser=None)
         value.value = self.set_token("10.0")
@@ -237,12 +230,57 @@ class TestGeneratorDeclarationVisitor(unittest.TestCase):
 
     # Named elements can be references to an enumeral or another property or in future a feature
     # The test must therefor test whether an group property, an enumeration and an inline enumeration can be resolved.
+
+    # This test tests property, local
+    def test_visitNamedElementReference_one_parameter(self):
+        model = self.parse_code("""
+            model eval
+            group test : "description" {
+                def param_a int : meter = 0
+                def param_b int : meter = param_a
+            }
+            """)
+
+        group:ParameterGroup = model._groups.get("test")
+        parameter_a:Parameter = group._parameters.get("param_a")
+        parameter_b:Parameter = group._parameters.get("param_b")
+
+        self.assertNotEqual(parameter_a, None, "Missing parameter a")
+        self.assertNotEqual(parameter_b, None, "Missing parameter b")
+
+        expression:ArithmeticExpression = parameter_b._default_value
+
+        self.assertNotEqual(expression, None, "Missing expression")
+
+        self.assertIsInstance(expression, Parameter, "Wrong type, Parameter expected")
+        self.assertEqual(parameter_a, expression, "Reference to the wrong element")
+
     # This test tests property, local
-    def test_visitNamedElementReference_one_property(self):
-        reference_context = DeclarationParser.NamedElementReferenceContext(parent=None, parser=None)
-        reference_context.elements = [self.set_token("a")]
+    def test_visitNamedElementReference_two_parameter(self):
+        model = self.parse_code("""
+            model eval
+            group test : "description" {
+                def param_a int : meter = 0
+            }
+            group test2 : "other" {
+                def param_b int : meter = test.param_a
+            }
+            """)
+
+        group_a:ParameterGroup = model._groups.get("test")
+        parameter_a:Parameter = group_a._parameters.get("param_a")
+        group_b:ParameterGroup = model._groups.get("test2")
+        parameter_b:Parameter = group_b._parameters.get("param_b")
+
+        self.assertNotEqual(parameter_a, None, "Missing parameter a")
+        self.assertNotEqual(parameter_b, None, "Missing parameter b")
 
-        result = self.make_visitor().visitNamedElementReference(reference_context)
+        expression:ArithmeticExpression = parameter_b._default_value
+
+        self.assertNotEqual(expression, None, "Missing expression")
+
+        self.assertIsInstance(expression, Parameter, "Wrong type, Parameter expected")
+        self.assertEqual(parameter_a, expression, "Reference to the wrong element")
 
     # This test tests enum based on context
     def test_visitNamedElementReference_one_enum(self):
@@ -258,11 +296,33 @@ class TestGeneratorDeclarationVisitor(unittest.TestCase):
         group:ParameterGroup = model._groups.get("test")
         parameter:Parameter = group._parameters.get("param")
         expression:ArithmeticExpression = parameter._default_value
-        print (f"{expression} {parameter}")
 
-    def test_visitNamedElementReference_two(self):
-        reference_context = DeclarationParser.NamedElementReferenceContext(parent=None, parser=None)
-        reference_context.elements = [self.set_token("a"), self.set_token("b")]
+        self.assertNotEqual(parameter, None, "Missing parameter")
+        self.assertNotEqual(expression, None, "Missing expression")
+        self.assertIsInstance(expression, Enumeral, "Missing enumeral")
+        self.assertEqual(expression.name, "blue", "Wrong enumeral name")
+        self.assertEqual(expression.value, 2, "Wrong enumeral value")
+
+    def test_visitNamedElementReference_two_enum(self):
+        model = self.parse_code("""
+            model eval
+            types
+                enum Color { red, green, blue }
+            group test : "description" {
+                def param Color : meter = Color.blue
+            }
+            """)
+
+        group:ParameterGroup = model._groups.get("test")
+        parameter:Parameter = group._parameters.get("param")
+        expression:ArithmeticExpression = parameter._default_value
+
+        self.assertNotEqual(parameter, None, "Missing parameter")
+        self.assertNotEqual(expression, None, "Missing expression")
+        self.assertIsInstance(expression, Enumeral, "Missing enumeral")
+        self.assertEqual(expression.name, "blue", "Wrong enumeral name")
+        self.assertEqual(expression.value, 2, "Wrong enumeral value")
 
-        result = self.make_visitor().visitNamedElementReference(reference_context)
 
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file

cp-dsl/test/generator/visitors/declaration_visitor_base_test.py

@@ -17,7 +17,7 @@ __author__ = "reiner"
 import unittest
 from generator.visitors.declaration_visitor import GeneratorDeclarationVisitor
 from model.declaration_model import DeclarationModel, ParameterGroup, Parameter, FeatureGroup, Feature
-from model.type_system import EnumeralType, Enumeral, RangeType, BaseType, ArrayType, Dimension, InternalEnumeralType, Enumeral
+from model.type_system import EnumeralType, Enumeral, RangeType, BaseType, ArrayType, Dimension, InlineEnumeralType, Enumeral
 from model.unit_model import UnitSpecification, UnitKind, UnitPrefix, SIUnit, CustomUnit, DivisionUnit, ExponentUnit
 from model.arithmetic_model import IntValue, StringValue, FloatValue, ArithmeticExpression, MultiplicationExpression, EMultiplicationOperator, EAdditionOperator
 from antlr4 import InputStream, CommonTokenStream

cp-dsl/test/generator/visitors/declaration_visitor_feature_test.py

@@ -17,7 +17,7 @@ __author__ = "reiner"
 import unittest
 from generator.visitors.declaration_visitor import GeneratorDeclarationVisitor
 from model.declaration_model import DeclarationModel, ParameterGroup, Parameter, FeatureGroup, Feature
-from model.type_system import EnumeralType, Enumeral, RangeType, BaseType, ArrayType, Dimension, InternalEnumeralType, Enumeral
+from model.type_system import EnumeralType, Enumeral, RangeType, BaseType, ArrayType, Dimension, InlineEnumeralType, Enumeral
 from model.unit_model import UnitSpecification, UnitKind, UnitPrefix, SIUnit, CustomUnit, DivisionUnit, ExponentUnit
 from model.arithmetic_model import IntValue, StringValue, FloatValue, ArithmeticExpression, MultiplicationExpression, EMultiplicationOperator, EAdditionOperator
 from antlr4 import InputStream, CommonTokenStream

cp-dsl/test/generator/visitors/declaration_visitor_parameter_test.py

@@ -17,7 +17,7 @@ __author__ = "reiner"
 import unittest
 from generator.visitors.declaration_visitor import GeneratorDeclarationVisitor
 from model.declaration_model import DeclarationModel, ParameterGroup, Parameter, FeatureGroup, Feature
-from model.type_system import EnumeralType, Enumeral, RangeType, BaseType, ArrayType, Dimension, InternalEnumeralType, Enumeral
+from model.type_system import EnumeralType, Enumeral, RangeType, BaseType, ArrayType, Dimension, InlineEnumeralType, Enumeral
 from model.unit_model import UnitSpecification, UnitKind, UnitPrefix, SIUnit, CustomUnit, DivisionUnit, ExponentUnit
 from model.arithmetic_model import IntValue, StringValue, FloatValue, ArithmeticExpression, MultiplicationExpression, EMultiplicationOperator, EAdditionOperator
 from antlr4 import InputStream, CommonTokenStream
@@ -42,4 +42,47 @@ class TestGeneratorDeclarationVisitor(unittest.TestCase):
 
     logger = GeneratorLogger(CompileFlags.STRICT)
 
+    def test_visitParamGroupAssignStat(self):
+        ctx = DeclarationParser.ParamGroupAssignStatContext(parser=None, ctx=DeclarationParser.DeclarationModelContext(parser=None))
+        ctx.name = self.set_token("group_name")
+        ctx.description = self.set_token("\"group description\"")
+
+        result = self.make_visitor().visitParamGroupAssignStat(ctx)
+
+        self.assertIsInstance(result, ParameterGroup, f"Wrong type {type(result)}")
+        self.assertEqual(result.name, "group_name", "Wrong name")
+        self.assertEqual(result._description, "group description", "Wrong description")
+
+
+    def test_visitParamAssignStat(self):
+        model = self.parse_code("model eval group g : \"group description\" { def param1 int : meter = 0 }")
+
+        group:ParameterGroup = model._groups.get("g")
+
+        self.assertIsInstance(group, ParameterGroup, f"Wrong type {type(group)}")
+        self.assertEqual(group.name, "g", "Wrong name")
+        self.assertEqual(group._description, "group description", "Wrong description")
+
+        t = BaseType("int")
+        self.assertEqual(len(group._parameters.values()), 1, "Wrong number of parameters")
+        for p in group._parameters.values():
+            self.assertEqual(p.name, "param1", "Wrong param name")
+            self.assertEqual(p._type, t, "Wrong type")
+            # TODO
+#            self.assertEqual(p._unit, u, "Should be meter")
+            self.assertEqual(p._default_value.value, 0, "Wrong value")
+            self.assertEqual(p._description, "", "Wrong description")
+
+
+    def test_visitParamType_type_reference(self):
+        param_type_context = DeclarationParser.ParamTypeContext(parent=None, parser=None)
+        type_reference = DeclarationParser.TypeReferenceContext(parent=param_type_context, parser=None)
+        type_reference.type_ = self.set_token("r")
+        param_type_context.addChild(type_reference)
+
+        result = self.make_visitor(type=RangeType(name="r", type=int, minimum=0, maximum=10)).visitParamType(param_type_context)
+
+        self.assertIsInstance(result, RangeType, "wrong type")
+        self.assertEqual(result.name, "r", "wrong type name")
+
 

cp-dsl/test/generator/visitors/declaration_visitor_type_declaration_test.py

@@ -17,7 +17,7 @@ __author__ = "reiner"
 import unittest
 from generator.visitors.declaration_visitor import GeneratorDeclarationVisitor
 from model.declaration_model import DeclarationModel, ParameterGroup, Parameter, FeatureGroup, Feature
-from model.type_system import EnumeralType, Enumeral, RangeType, BaseType, ArrayType, Dimension, InternalEnumeralType, Enumeral
+from model.type_system import EnumeralType, Enumeral, RangeType, BaseType, ArrayType, Dimension, InlineEnumeralType, Enumeral
 from model.unit_model import UnitSpecification, UnitKind, UnitPrefix, SIUnit, CustomUnit, DivisionUnit, ExponentUnit
 from model.arithmetic_model import IntValue, StringValue, FloatValue, ArithmeticExpression, MultiplicationExpression, EMultiplicationOperator, EAdditionOperator
 from antlr4 import InputStream, CommonTokenStream
@@ -83,51 +83,6 @@ class TestGeneratorDeclarationVisitor(unittest.TestCase):
         self.assertEqual(result.name, "red", "Wrong name")
         self.assertEqual(result.value, 0)
 
-    def test_visitParamGroupAssignStat(self):
-        ctx = DeclarationParser.ParamGroupAssignStatContext(parser=None, ctx=DeclarationParser.DeclarationModelContext(parser=None))
-        ctx.name = self.set_token("group_name")
-        ctx.description = self.set_token("\"group description\"")
-
-        result = self.make_visitor().visitParamGroupAssignStat(ctx)
-
-        self.assertIsInstance(result, ParameterGroup, f"Wrong type {type(result)}")
-        self.assertEqual(result.name, "group_name", "Wrong name")
-        self.assertEqual(result._description, "group description", "Wrong description")
-
-    def test_visitParamAssignStat(self):
-        model = self.parse_code("model eval group g : \"group description\" { def param1 int : meter = 0 }")
-
-        group:ParameterGroup = model._groups.get("g")
-
-        self.assertIsInstance(group, ParameterGroup, f"Wrong type {type(group)}")
-        self.assertEqual(group.name, "g", "Wrong name")
-        self.assertEqual(group._description, "group description", "Wrong description")
-
-        t = BaseType("int")
-        self.assertEqual(len(group._parameters.values()), 1, "Wrong number of parameters")
-        for p in group._parameters.values():
-            self.assertEqual(p.name, "param1", "Wrong param name")
-            self.assertEqual(p._type, t, "Wrong type")
-            # TODO
-#            self.assertEqual(p._unit, u, "Should be meter")
-            self.assertEqual(p._default_value.value, 0, "Wrong value")
-            self.assertEqual(p._description, "", "Wrong description")
-
-    def test_visitParamType_type_reference(self):
-        param_type_context = DeclarationParser.ParamTypeContext(parent=None, parser=None)
-        type_reference = DeclarationParser.TypeReferenceContext(parent=param_type_context, parser=None)
-        type_reference.type_ = self.set_token("r")
-        param_type_context.addChild(type_reference)
-
-        result = self.make_visitor(type=RangeType(name="r", type=int, minimum=0, maximum=10)).visitParamType(param_type_context)
-
-        self.assertIsInstance(result, RangeType, "wrong type")
-        self.assertEqual(result.name, "r", "wrong type name")
-
-#        param_type_context.inlineEnumerationType()
-
-#        param_type_context.arrayType()
-
     def test_visitParamType_inline_enumeration_type(self):
         param_type_context = DeclarationParser.ParamTypeContext(parent=None, parser=None)
         inline_enumeration_type = DeclarationParser.InlineEnumerationTypeContext(parent=param_type_context, parser=None)
@@ -148,7 +103,7 @@ class TestGeneratorDeclarationVisitor(unittest.TestCase):
 
         result = self.make_visitor().visitParamType(param_type_context)
 
-        self.assertIsInstance(result, InternalEnumeralType, "wrong type")
+        self.assertIsInstance(result, InlineEnumeralType, "wrong type")
         self.assertEqual(len(result._enumerals),2, "Wrong number")
         self.assertEqual(list(result._enumerals.keys()), ["FIRST", "SECOND"], "Wrong keys")
         enumerals = list(result._enumerals.values())
@@ -307,8 +262,6 @@ class TestGeneratorDeclarationVisitor(unittest.TestCase):
         self.assertIsInstance(result, RangeType, "wrong type")
         self.assertEqual(result.name, "r", "wrong type name")
 
-
-
     def test_visitInlineEnumerationType(self):
         model = self.parse_code("model eval group g : \"group description\" { def param1 ( RED, GREEN, BLUE ) : meter = BLUE }")
 
@@ -321,8 +274,8 @@ class TestGeneratorDeclarationVisitor(unittest.TestCase):
         self.assertEqual(len(group._parameters.values()), 1, "Wrong number of parameters")
         for p in group._parameters.values():
             self.assertEqual(p.name, "param1", "Wrong param name")
-            self.assertIsInstance(p._type, InternalEnumeralType, "Wrong type")
-            enumeral_type:InternalEnumeralType = p._type
+            self.assertIsInstance(p._type, InlineEnumeralType, "Wrong type")
+            enumeral_type:InlineEnumeralType = p._type
             self.assertEqual(len(enumeral_type._enumerals), 3, "Wrong number of enumerals")
             self.assertEqual(enumeral_type._enumerals.get("RED").name, "RED", "Not red")
             self.assertEqual(enumeral_type._enumerals.get("RED").value, 0, "Not 0 for red")

cp-dsl/test/generator/visitors/declaration_visitor_units_test.py

@@ -17,7 +17,7 @@ __author__ = "reiner"
 import unittest
 from generator.visitors.declaration_visitor import GeneratorDeclarationVisitor
 from model.declaration_model import DeclarationModel, ParameterGroup, Parameter, FeatureGroup, Feature
-from model.type_system import EnumeralType, Enumeral, RangeType, BaseType, ArrayType, Dimension, InternalEnumeralType, Enumeral
+from model.type_system import EnumeralType, Enumeral, RangeType, BaseType, ArrayType, Dimension, InlineEnumeralType, Enumeral
 from model.unit_model import UnitSpecification, UnitKind, UnitPrefix, SIUnit, CustomUnit, DivisionUnit, ExponentUnit
 from model.arithmetic_model import IntValue, StringValue, FloatValue, ArithmeticExpression, MultiplicationExpression, EMultiplicationOperator, EAdditionOperator
 from antlr4 import InputStream, CommonTokenStream

cp-dsl/test/generator/visitors/test_utils.py

+#  Copyright (c) 2023.  OceanDSL (https://oceandsl.uni-kiel.de)
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributedBaseType on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+__author__ = "reiner"
+
+import unittest
+from generator.visitors.declaration_visitor import GeneratorDeclarationVisitor
+from model.declaration_model import DeclarationModel
+from antlr4 import InputStream, CommonTokenStream
+from antlr4.Token import CommonToken
+from antlr4 import TerminalNode
+from antlr4.tree.Tree import TerminalNodeImpl
+
+from dcllspserver.gen.python.Declaration.DeclarationLexer import DeclarationLexer
+from dcllspserver.gen.python.Declaration.DeclarationParser import DeclarationParser
+
+from common.logger import GeneratorLogger
+from common.configuration import CompileFlags
+
+class TestStream(InputStream):
+
+    fileName = "test"
+
+    def __init__(self, data: str) -> None:
+        super().__init__(data)
+
+class TestGeneratorDeclarationVisitorBase(unittest.TestCase):
+
+    logger = GeneratorLogger(CompileFlags.STRICT)
+
+    def make_visitor(self, type=None) -> GeneratorDeclarationVisitor:
+        model = DeclarationModel()
+        if type is not None:
+            model._types[type.name] = type
+        return GeneratorDeclarationVisitor(model, self.logger)
+
+    def set_terminal(self, value:str) -> TerminalNode:
+        return TerminalNodeImpl(self.set_token(value))
+
+    def set_token(self, value:str) -> CommonToken:
+        token = CommonToken()
+        token.text = value
+        return token
+
+    def parse_code(self, code:str) -> DeclarationModel:
+        model = DeclarationModel()
+        visitor = GeneratorDeclarationVisitor(model, self.logger)
+
+        input_stream = TestStream(code)
+
+        lexer = DeclarationLexer(input_stream)
+        stream = CommonTokenStream(lexer)
+        parser = DeclarationParser(stream)
+
+        visitor.visit(parser.declarationModel())
+
+        return model