aas-core-codegen 0.0.16__py3-none-any.whl

dev/test_data/smoke/test_main/unexpected/infer_for_schema_error/meta_model.py

@@ -0,0 +1,12 @@
+# The invariants are contradicting.
+@invariant(lambda self: len(self.some_prop) == 10)
+@invariant(lambda self: len(self.some_prop) == 11)
+class Something:
+    some_prop: str
+
+    def __init__(self, some_prop: str) -> None:
+        self.some_prop = some_prop
+
+
+__version__ = "dummy"
+__xml_namespace__ = "https://dummy.com"

dev/test_data/smoke/test_main/unexpected/intermediate_error/meta_model.py

@@ -0,0 +1,18 @@
+# ``with_model_type`` is missing in the serialization.
+class Something:
+    pass
+
+
+class Concrete(Something):
+    pass
+
+
+class Bundle:
+    something: Something
+
+    def __init__(self, something: Something) -> None:
+        self.something = something
+
+
+__version__ = "dummy"
+__xml_namespace__ = "https://dummy.com"

dev/test_data/smoke/test_main/unexpected/parse_error/meta_model.py

@@ -0,0 +1,5 @@
+class Something:
+    pass
+
+
+# No book version will cause an error.

dev/test_data/smoke/test_main/unexpected/pattern_verification_unparsable_regex/direct_match/meta_model.py

@@ -0,0 +1,8 @@
+@verification
+def match_something(text: str) -> None:
+    # The regular expression is invalid.
+    return re.match(r"^x(", text)
+
+
+__version__ = "dummy"
+__xml_namespace__ = "https://dummy.com"

dev/test_data/smoke/test_main/unexpected/type_error/meta_model.py

@@ -0,0 +1,18 @@
+class Value:
+    text: str
+
+    def __init__(self, text: str) -> None:
+        self.text = text
+
+
+# ERROR: ``len(.)`` on a class is not defined.
+@invariant(lambda self: len(self.value) > 1, "Value longer than 1")
+class Something:
+    value: Value
+
+    def __init__(self, value: Value) -> None:
+        self.value = value
+
+
+__version__ = "dummy"
+__xml_namespace__ = "https://dummy.com"

dev/tests/__init__.py

@@ -0,0 +1 @@
+# BEFORE-RELEASE (mristin, 2021-12-13): re-do all the recordings before the release!

dev/tests/common.py

@@ -0,0 +1,197 @@
+"""Provide common functionality across different tests."""
+import os
+import pathlib
+from typing import List, Tuple, Optional, Union, Sequence, Final
+
+import asttokens
+from icontract import ensure, require
+
+from aas_core_codegen import parse, intermediate
+from aas_core_codegen.common import Error
+
+
+# pylint: disable=missing-function-docstring
+
+
+def most_underlying_messages(error_or_errors: Union[Error, Sequence[Error]]) -> str:
+    """Find the "leaf" errors and render them as a new-line separated list."""
+    if isinstance(error_or_errors, Error):
+        errors = [error_or_errors]  # type: Sequence[Error]
+    else:
+        errors = error_or_errors
+
+    most_underlying_errors = []  # type: List[Error]
+
+    for error in errors:
+        if error.underlying is None or len(error.underlying) == 0:
+            most_underlying_errors.append(error)
+            continue
+
+        stack = error.underlying  # type: List[Error]
+
+        while len(stack) > 0:
+            top_error = stack.pop()
+
+            if top_error.underlying is not None:
+                stack.extend(top_error.underlying)
+
+            if top_error.underlying is None or len(top_error.underlying) == 0:
+                most_underlying_errors.append(top_error)
+
+    return "\n".join(
+        most_underlying_error.message
+        for most_underlying_error in most_underlying_errors
+    )
+
+
+@ensure(lambda result: (result[0] is not None) ^ (result[1] is not None))
+def parse_atok(
+    atok: asttokens.ASTTokens,
+) -> Tuple[Optional[parse.SymbolTable], Optional[Error]]:
+    """Parse the ``atok``, an abstract syntax tree of a meta-model."""
+    import_errors = parse.check_expected_imports(atok=atok)
+    if len(import_errors) > 0:
+        import_errors_str = "\n".join(
+            f"* {import_error}" for import_error in import_errors
+        )
+
+        raise AssertionError(
+            f"Unexpected imports in the source code:\n{import_errors_str}"
+        )
+
+    symbol_table, error = parse.atok_to_symbol_table(atok=atok)
+    return symbol_table, error
+
+
+@ensure(lambda result: (result[0] is not None) ^ (result[1] is not None))
+def parse_source(source: str) -> Tuple[Optional[parse.SymbolTable], Optional[Error]]:
+    """Parse the given source text into a symbol table."""
+    atok, parse_exception = parse.source_to_atok(source=source)
+    if parse_exception:
+        raise parse_exception  # pylint: disable=raising-bad-type
+
+    assert atok is not None
+
+    return parse_atok(atok=atok)
+
+
+@ensure(lambda result: (result[0] is not None) ^ (result[1] is not None))
+def translate_source_to_intermediate(
+    source: str,
+) -> Tuple[Optional[intermediate.SymbolTable], Optional[Error]]:
+    atok, parse_exception = parse.source_to_atok(source=source)
+    if parse_exception:
+        raise parse_exception  # pylint: disable=raising-bad-type
+
+    assert atok is not None
+
+    parsed_symbol_table, error = parse_atok(atok=atok)
+    assert error is None, f"{most_underlying_messages(error)}"
+    assert parsed_symbol_table is not None
+
+    return intermediate.translate(parsed_symbol_table=parsed_symbol_table, atok=atok)
+
+
+def must_translate_source_to_intermediate(
+    source: str,
+) -> intermediate.SymbolTable:
+    atok, parse_exception = parse.source_to_atok(source=source)
+    if parse_exception:
+        raise parse_exception  # pylint: disable=raising-bad-type
+
+    assert atok is not None
+
+    parsed_symbol_table, error = parse_atok(atok=atok)
+    assert error is None, f"{most_underlying_messages(error)}"
+    assert parsed_symbol_table is not None
+
+    symbol_table, error = intermediate.translate(
+        parsed_symbol_table=parsed_symbol_table, atok=atok
+    )
+    assert (
+        error is None
+    ), f"Unexpected error when parsing the source: {most_underlying_messages(error)}"
+    assert symbol_table is not None
+    return symbol_table
+
+
+#: If set, this environment variable indicates that the golden files should be
+#: re-recorded instead of checked against.
+RERECORD = os.environ.get("AAS_CORE_CODEGEN_RERECORD", "").lower() in (
+    "1",
+    "true",
+    "on",
+)
+
+
+class TestCaseWithDirectoryAndMetaModel:
+    """Represent a test case with files in a test directory and a meta-model."""
+
+    #: Path to the expected files and other test data
+    case_dir: Final[pathlib.Path]
+
+    #: Path to the meta-model file corresponding to the test case
+    model_path: Final[pathlib.Path]
+
+    def __init__(self, case_dir: pathlib.Path, model_path: pathlib.Path) -> None:
+        """Initialize with the given values."""
+        self.case_dir = case_dir
+        self.model_path = model_path
+
+
+@require(lambda base_case_dir: base_case_dir.exists() and base_case_dir.is_dir())
+def test_cases_from_base_case_dir(
+    base_case_dir: pathlib.Path,
+) -> List[TestCaseWithDirectoryAndMetaModel]:
+    """
+    Find meta-model files beneath the ``base_case_dir``.
+
+    We resolve the meta-model source by checking for each test case directory if
+    the file ``meta_model.py`` exists.
+
+    :param base_case_dir: parent directory where test cases reside
+    :return: list of found test cases
+    """
+    test_cases = []  # type: List[TestCaseWithDirectoryAndMetaModel]
+
+    for case_dir in sorted(pth for pth in base_case_dir.iterdir() if pth.is_dir()):
+        model_pth = case_dir / "meta_model.py"  # type: Optional[pathlib.Path]
+        assert model_pth is not None
+
+        if model_pth.exists():
+            test_cases.append(
+                TestCaseWithDirectoryAndMetaModel(
+                    case_dir=case_dir, model_path=model_pth
+                )
+            )
+            continue
+
+    return test_cases
+
+
+@require(lambda base_case_dir: base_case_dir.exists() and base_case_dir.is_dir())
+def test_cases_from_real_world_models(
+    base_case_dir: pathlib.Path, real_meta_model_paths: Sequence[pathlib.Path]
+) -> List[TestCaseWithDirectoryAndMetaModel]:
+    """
+    Find the test cases for the given real-world models.
+
+    The meta-model path will point to the real-world model, which is shared across many
+    different tests, while the case directory will be situated beneath
+    the ``base_case_dir`` corresponding to the file name of the real-world model.
+    """
+    return [
+        TestCaseWithDirectoryAndMetaModel(
+            case_dir=base_case_dir / model_pth.stem, model_path=model_pth
+        )
+        for model_pth in real_meta_model_paths
+    ]
+
+
+def _repo_root() -> pathlib.Path:
+    return pathlib.Path(os.path.realpath(__file__)).parent.parent.parent
+
+
+REAL_META_MODEL_PATHS: Final[Sequence[pathlib.Path]] = [
+    _repo_root() / "dev/test_data/real_meta_models/aas_core_meta.v3.py"
+]

dev/tests/cpp/test_common.py

@@ -0,0 +1,32 @@
+# pylint: disable=missing-docstring
+
+import unittest
+
+from aas_core_codegen.cpp import common as cpp_common
+
+
+class TestBreakTypeInLines(unittest.TestCase):
+    def test_empty(self) -> None:
+        result = cpp_common.break_type_in_lines("")
+        self.assertEqual(result, "")
+
+    def test_no_breaks(self) -> None:
+        result = cpp_common.break_type_in_lines("const int")
+        self.assertEqual("const int", result)
+
+    def test_breaks(self) -> None:
+        result = cpp_common.break_type_in_lines(
+            "std::optional<std::vector<std::shared_ptr<IEmbeddedDataSpecification> > >&"
+        )
+        self.assertEqual(
+            """\
+std::optional<
+  std::vector<
+    std::shared_ptr<
+      IEmbeddedDataSpecification > > >&""",
+            result,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/cpp/test_main.py

@@ -0,0 +1,144 @@
+# pylint: disable=missing-docstring
+
+import contextlib
+import io
+import os
+import pathlib
+import tempfile
+import unittest
+
+import aas_core_codegen.main
+
+import tests.common
+
+
+class Test_against_recorded(unittest.TestCase):
+    def test_cases(self) -> None:
+        repo_dir = pathlib.Path(os.path.realpath(__file__)).parent.parent.parent.parent
+
+        parent_case_dir = repo_dir / "dev" / "test_data" / "cpp" / "test_main"
+        assert parent_case_dir.exists() and parent_case_dir.is_dir(), parent_case_dir
+
+        for model_pth in tests.common.REAL_META_MODEL_PATHS:
+            case_dir = parent_case_dir / model_pth.stem
+            assert case_dir.is_dir(), case_dir
+
+            snippets_dir = case_dir / "input/snippets"
+            assert snippets_dir.exists() and snippets_dir.is_dir(), snippets_dir
+
+            expected_output_dir = case_dir / "expected_output"
+
+            with contextlib.ExitStack() as exit_stack:
+                if tests.common.RERECORD:
+                    output_dir = expected_output_dir
+                    expected_output_dir.mkdir(exist_ok=True, parents=True)
+                else:
+                    assert (
+                        expected_output_dir.exists() and expected_output_dir.is_dir()
+                    ), expected_output_dir
+
+                    # pylint: disable=consider-using-with
+                    tmp_dir = tempfile.TemporaryDirectory()
+                    exit_stack.push(tmp_dir)
+                    output_dir = pathlib.Path(tmp_dir.name)
+
+                params = aas_core_codegen.main.Parameters(
+                    model_path=model_pth,
+                    target=aas_core_codegen.main.Target.CPP,
+                    snippets_dir=snippets_dir,
+                    output_dir=output_dir,
+                )
+
+                stdout = io.StringIO()
+                stderr = io.StringIO()
+
+                return_code = aas_core_codegen.main.execute(
+                    params=params, stdout=stdout, stderr=stderr
+                )
+
+                if stderr.getvalue() != "":
+                    raise AssertionError(
+                        f"Expected no stderr on valid models, but got:\n"
+                        f"{stderr.getvalue()}"
+                    )
+
+                self.assertEqual(
+                    0, return_code, "Expected 0 return code on valid models"
+                )
+
+                stdout_pth = expected_output_dir / "stdout.txt"
+                normalized_stdout = stdout.getvalue().replace(
+                    str(output_dir), "<output dir>"
+                )
+
+                if tests.common.RERECORD:
+                    stdout_pth.write_text(normalized_stdout, encoding="utf-8")
+                else:
+                    self.assertEqual(
+                        normalized_stdout,
+                        stdout_pth.read_text(encoding="utf-8"),
+                        stdout_pth,
+                    )
+
+                for relevant_rel_pth in [
+                    pathlib.Path("common.hpp"),
+                    pathlib.Path("common.cpp"),
+                    pathlib.Path("constants.hpp"),
+                    pathlib.Path("constants.cpp"),
+                    pathlib.Path("enhancing.hpp"),
+                    pathlib.Path("iteration.hpp"),
+                    pathlib.Path("iteration.cpp"),
+                    pathlib.Path("jsonization.hpp"),
+                    pathlib.Path("jsonization.cpp"),
+                    pathlib.Path("pattern.hpp"),
+                    pathlib.Path("pattern.cpp"),
+                    pathlib.Path("revm.hpp"),
+                    pathlib.Path("revm.cpp"),
+                    pathlib.Path("stringification.hpp"),
+                    pathlib.Path("stringification.cpp"),
+                    pathlib.Path("types.hpp"),
+                    pathlib.Path("types.cpp"),
+                    pathlib.Path("verification.hpp"),
+                    pathlib.Path("verification.cpp"),
+                    pathlib.Path("visitation.hpp"),
+                    pathlib.Path("visitation.cpp"),
+                    pathlib.Path("xmlization.hpp"),
+                    pathlib.Path("xmlization.cpp"),
+                    pathlib.Path("wstringification.hpp"),
+                    pathlib.Path("wstringification.cpp"),
+                ]:
+                    expected_pth = expected_output_dir / relevant_rel_pth
+                    output_pth = output_dir / relevant_rel_pth
+
+                    if not output_pth.exists():
+                        raise FileNotFoundError(
+                            f"The output file is missing: {output_pth}"
+                        )
+
+                    try:
+                        output = output_pth.read_text(encoding="utf-8")
+                    except Exception as exception:
+                        raise RuntimeError(
+                            f"Failed to read the output from {output_pth}"
+                        ) from exception
+
+                    if tests.common.RERECORD:
+                        expected_pth.write_text(output, encoding="utf-8")
+                    else:
+                        try:
+                            expected_output = expected_pth.read_text(encoding="utf-8")
+                        except Exception as exception:
+                            raise RuntimeError(
+                                f"Failed to read the expected output "
+                                f"from {expected_pth}"
+                            ) from exception
+
+                        self.assertEqual(
+                            expected_output,
+                            output,
+                            f"The files {expected_pth} and {output_pth} do not match.",
+                        )
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/cpp/test_pattern.py

@@ -0,0 +1,188 @@
+# pylint: disable=missing-docstring
+
+import unittest
+
+from aas_core_codegen.parse import retree as parse_retree
+from aas_core_codegen.cpp import pattern as cpp_pattern
+
+
+class TestForRealWorldPatterns(unittest.TestCase):
+    def test_for_xs_date_prefix(self) -> None:
+        pattern = "^(-?[0-9]+)-(0[1-9]|1[0-2])-(0[0-9]|1[0-9]|2[0-9]|30|31).*$"
+
+        regex, error = parse_retree.parse([pattern])
+        assert error is None, f"{error=}"
+        assert regex is not None
+
+        code = cpp_pattern._generate._generate_program_definition_for_regex(regex=regex)
+        self.assertEqual(
+            """\
+std::vector<std::unique_ptr<revm::Instruction> > program;
+
+{  // ^(-?[0-9]+)-(0[1-9]|1[0-2])-(0[0-9]|1[0-9]|2[0-9]|30|31).*$
+  {  // -?[0-9]+
+    {  // -?
+      program.emplace_back(
+        std::make_unique<revm::InstructionSplit>(1, 2)
+      );
+      // -
+      program.emplace_back(  // 1
+        std::make_unique<revm::InstructionChar>(L'-')
+      );
+    }  // -?
+    {  // [0-9]+
+      // [0-9]
+      program.emplace_back(  // 2
+        std::make_unique<revm::InstructionSet>(
+          std::vector<revm::Range>{
+            revm::Range(L'0', L'9')
+          }
+        )
+      );
+      program.emplace_back(
+        std::make_unique<revm::InstructionSplit>(2, 4)
+      );
+    }  // [0-9]+
+  }  // -?[0-9]+
+  // -
+  program.emplace_back(  // 4
+    std::make_unique<revm::InstructionChar>(L'-')
+  );
+  {  // 0[1-9]|1[0-2]
+    program.emplace_back(
+      std::make_unique<revm::InstructionSplit>(6, 9)
+    );
+    {  // 0[1-9]
+      // 0
+      program.emplace_back(  // 6
+        std::make_unique<revm::InstructionChar>(L'0')
+      );
+      // [1-9]
+      program.emplace_back(
+        std::make_unique<revm::InstructionSet>(
+          std::vector<revm::Range>{
+            revm::Range(L'1', L'9')
+          }
+        )
+      );
+    }  // 0[1-9]
+    program.emplace_back(
+      std::make_unique<revm::InstructionJump>(11)
+    );
+    {  // 1[0-2]
+      // 1
+      program.emplace_back(  // 9
+        std::make_unique<revm::InstructionChar>(L'1')
+      );
+      // [0-2]
+      program.emplace_back(
+        std::make_unique<revm::InstructionSet>(
+          std::vector<revm::Range>{
+            revm::Range(L'0', L'2')
+          }
+        )
+      );
+    }  // 1[0-2]
+  }  // 0[1-9]|1[0-2]
+  // -
+  program.emplace_back(  // 11
+    std::make_unique<revm::InstructionChar>(L'-')
+  );
+  {  // 0[0-9]|1[0-9]|2[0-9]|30|31
+    program.emplace_back(
+      std::make_unique<revm::InstructionSplit>(13, 16)
+    );
+    {  // 0[0-9]
+      // 0
+      program.emplace_back(  // 13
+        std::make_unique<revm::InstructionChar>(L'0')
+      );
+      // [0-9]
+      program.emplace_back(
+        std::make_unique<revm::InstructionSet>(
+          std::vector<revm::Range>{
+            revm::Range(L'0', L'9')
+          }
+        )
+      );
+    }  // 0[0-9]
+    program.emplace_back(
+      std::make_unique<revm::InstructionJump>(30)
+    );
+    program.emplace_back(  // 16
+      std::make_unique<revm::InstructionSplit>(17, 20)
+    );
+    {  // 1[0-9]
+      // 1
+      program.emplace_back(  // 17
+        std::make_unique<revm::InstructionChar>(L'1')
+      );
+      // [0-9]
+      program.emplace_back(
+        std::make_unique<revm::InstructionSet>(
+          std::vector<revm::Range>{
+            revm::Range(L'0', L'9')
+          }
+        )
+      );
+    }  // 1[0-9]
+    program.emplace_back(
+      std::make_unique<revm::InstructionJump>(30)
+    );
+    program.emplace_back(  // 20
+      std::make_unique<revm::InstructionSplit>(21, 24)
+    );
+    {  // 2[0-9]
+      // 2
+      program.emplace_back(  // 21
+        std::make_unique<revm::InstructionChar>(L'2')
+      );
+      // [0-9]
+      program.emplace_back(
+        std::make_unique<revm::InstructionSet>(
+          std::vector<revm::Range>{
+            revm::Range(L'0', L'9')
+          }
+        )
+      );
+    }  // 2[0-9]
+    program.emplace_back(
+      std::make_unique<revm::InstructionJump>(30)
+    );
+    program.emplace_back(  // 24
+      std::make_unique<revm::InstructionSplit>(25, 28)
+    );
+    {  // 30
+      // 3
+      program.emplace_back(  // 25
+        std::make_unique<revm::InstructionChar>(L'3')
+      );
+      // 0
+      program.emplace_back(
+        std::make_unique<revm::InstructionChar>(L'0')
+      );
+    }  // 30
+    program.emplace_back(
+      std::make_unique<revm::InstructionJump>(30)
+    );
+    {  // 31
+      // 3
+      program.emplace_back(  // 28
+        std::make_unique<revm::InstructionChar>(L'3')
+      );
+      // 1
+      program.emplace_back(
+        std::make_unique<revm::InstructionChar>(L'1')
+      );
+    }  // 31
+  }  // 0[0-9]|1[0-9]|2[0-9]|30|31
+  program.emplace_back(  // 30
+    std::make_unique<revm::InstructionMatch>()
+  );
+}  // ^(-?[0-9]+)-(0[1-9]|1[0-2])-(0[0-9]|1[0-9]|2[0-9]|30|31).*$""",
+            code,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()