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

dev/tests/csharp/test_main.py

@@ -0,0 +1,129 @@
+# 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" / "csharp" / "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.CSHARP,
+                    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("types.cs"),
+                    pathlib.Path("visitation.cs"),
+                    pathlib.Path("constants.cs"),
+                    pathlib.Path("verification.cs"),
+                    pathlib.Path("reporting.cs"),
+                    pathlib.Path("stringification.cs"),
+                    pathlib.Path("jsonization.cs"),
+                    pathlib.Path("xmlization.cs"),
+                    pathlib.Path("copying.cs"),
+                    pathlib.Path("enhancing.cs"),
+                ]:
+                    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/csharp/test_structure.py

@@ -0,0 +1,93 @@
+# pylint: disable=missing-docstring
+import os
+import pathlib
+import unittest
+
+from aas_core_codegen import intermediate
+from aas_core_codegen.common import LinenoColumner, Error
+from aas_core_codegen.csharp import (
+    common as csharp_common,
+    structure as csharp_structure,
+)
+from aas_core_codegen import parse
+
+import tests.common
+
+
+class Test_generation_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/csharp/test_structure"
+        assert parent_case_dir.exists() and parent_case_dir.is_dir(), parent_case_dir
+
+        for model_pth in sorted(parent_case_dir.glob("**/meta_model.py")):
+            text = model_pth.read_text(encoding="utf-8")
+            atok, parse_exception = parse.source_to_atok(source=text)
+            assert (
+                parse_exception is None
+            ), f"Unexpected parse exception in {model_pth}: {parse_exception=}"
+            assert atok is not None
+
+            lineno_columner = LinenoColumner(atok=atok)
+            parsed_symbol_table, error = parse.atok_to_symbol_table(atok=atok)
+
+            assert error is None, (
+                f"Unexpected error in parsing {model_pth}: "
+                f"{lineno_columner.error_message(error)}"
+            )
+            assert parsed_symbol_table is not None
+
+            ir_symbol_table, error = intermediate.translate(
+                parsed_symbol_table=parsed_symbol_table,
+                atok=atok,
+            )
+
+            assert error is None, (
+                f"Unexpected error in translating {model_pth} to intermediate: "
+                f"{lineno_columner.error_message(error)}"
+            )
+            assert ir_symbol_table is not None
+
+            verified_symbol_table, errors = csharp_structure.verify(
+                symbol_table=ir_symbol_table
+            )
+            if errors is not None:
+                joined_error = Error(
+                    None, "Generating verification code failed", errors
+                )
+                raise AssertionError(
+                    f"Unexpected errors when verifying "
+                    f"{model_pth}: {lineno_columner.error_message(joined_error)}"
+                )
+            assert verified_symbol_table is not None
+
+            code, errors = csharp_structure.generate(
+                symbol_table=verified_symbol_table,
+                namespace=csharp_common.NamespaceIdentifier("dummyNamespace"),
+                spec_impls=dict(),
+            )
+            if errors is not None:
+                joined_error = Error(None, "Generating structure code failed", errors)
+                raise AssertionError(
+                    f"Unexpected errors in generating structure code "
+                    f"for {model_pth}: {lineno_columner.error_message(joined_error)}"
+                )
+            assert code is not None
+
+            expected_pth = model_pth.parent / "expected_types.cs"
+            if tests.common.RERECORD:
+                expected_pth.write_text(code, encoding="utf-8")
+            else:
+                try:
+                    expected_code = expected_pth.read_text(encoding="utf-8")
+                except Exception as exception:
+                    raise RuntimeError(
+                        f"Failed to read the expected code from {expected_pth}"
+                    ) from exception
+
+                self.assertEqual(expected_code, code)
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/csharp/test_verification.py

@@ -0,0 +1,82 @@
+# pylint: disable=missing-docstring
+import os
+import pathlib
+import unittest
+
+from aas_core_codegen import intermediate
+from aas_core_codegen.common import LinenoColumner, Error
+from aas_core_codegen.csharp import (
+    common as csharp_common,
+    verification as csharp_verification,
+)
+from aas_core_codegen import parse
+
+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/csharp/test_verification"
+        assert parent_case_dir.exists() and parent_case_dir.is_dir(), parent_case_dir
+
+        for model_pth in sorted(parent_case_dir.glob("**/meta_model.py")):
+            text = model_pth.read_text(encoding="utf-8")
+            atok, parse_exception = parse.source_to_atok(source=text)
+            assert (
+                parse_exception is None
+            ), f"Unexpected parse exception in {model_pth}: {parse_exception=}"
+            assert atok is not None
+
+            lineno_columner = LinenoColumner(atok=atok)
+            parsed_symbol_table, error = parse.atok_to_symbol_table(atok=atok)
+
+            assert error is None, (
+                f"Unexpected error in parsing {model_pth}: "
+                f"{lineno_columner.error_message(error)}"
+            )
+            assert parsed_symbol_table is not None
+
+            ir_symbol_table, error = intermediate.translate(
+                parsed_symbol_table=parsed_symbol_table,
+                atok=atok,
+            )
+
+            assert error is None, (
+                f"Unexpected error in translating {model_pth} to intermediate: "
+                f"{lineno_columner.error_message(error)}"
+            )
+            assert ir_symbol_table is not None
+
+            code, errors = csharp_verification.generate(
+                symbol_table=ir_symbol_table,
+                namespace=csharp_common.NamespaceIdentifier("dummyNamespace"),
+                spec_impls=dict(),
+            )
+            if errors is not None:
+                joined_error = Error(
+                    None, "Generating verification code failed", errors
+                )
+                raise AssertionError(
+                    f"Unexpected errors in generating verification code "
+                    f"for {model_pth}: {lineno_columner.error_message(joined_error)}"
+                )
+            assert code is not None
+
+            expected_pth = model_pth.parent / "expected_verification.cs"
+            if tests.common.RERECORD:
+                expected_pth.write_text(code, encoding="utf-8")
+            else:
+                try:
+                    expected_code = expected_pth.read_text(encoding="utf-8")
+                except Exception as exception:
+                    raise RuntimeError(
+                        f"Failed to read the expected code from {expected_pth}"
+                    ) from exception
+
+                self.assertEqual(expected_code, code)
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/description.py

@@ -0,0 +1,29 @@
+"""Provide parsing functions to get started with testing some of the ReST rendering."""
+import io
+from typing import Optional
+
+import docutils.nodes
+import docutils.core
+
+
+def parse_restructured_text(text: str) -> docutils.nodes.document:
+    """Parse the given ReST ``text``."""
+    warnings = io.StringIO()
+    # noinspection PyUnusedLocal
+    document = None  # type: Optional[docutils.nodes.document]
+
+    document = docutils.core.publish_doctree(
+        text, settings_overrides={"warning_stream": warnings}
+    )
+
+    warnings_text = warnings.getvalue()
+    if warnings_text:
+        raise RuntimeError(
+            f"Failed to parse the description with docutils:\n"
+            f"{warnings_text.strip()}\n\n"
+            f"The original text was: {text!r}"
+        )
+
+    assert document is not None
+
+    return document

dev/tests/golang/test_common.py

@@ -0,0 +1,78 @@
+# pylint: disable=missing-docstring
+
+import unittest
+
+import aas_core_codegen.golang.common as golang_common
+
+
+class TestStringLiteral(unittest.TestCase):
+    def test_empty(self) -> None:
+        self.assertEqual('""', golang_common.string_literal(""))
+
+    def test_no_quotes(self) -> None:
+        self.assertEqual('"x"', golang_common.string_literal("x"))
+
+    def test_double_quotes_but_no_single_quotes(self) -> None:
+        self.assertEqual('"a\\"b"', golang_common.string_literal('a"b'))
+
+    def test_single_quotes_but_no_double_quotes(self) -> None:
+        self.assertEqual('"a\'b"', golang_common.string_literal("a'b"))
+
+    def test_tab(self) -> None:
+        self.assertEqual('"a\\tb"', golang_common.string_literal("a\tb"))
+
+
+class TestBytesLiteral(unittest.TestCase):
+    def test_empty(self) -> None:
+        self.assertTupleEqual(
+            ("[...]byte{}", False), golang_common.bytes_literal(bytearray(b""))
+        )
+
+    def test_one(self) -> None:
+        self.assertTupleEqual(
+            ("[...]byte{0x00}", False),
+            golang_common.bytes_literal(bytearray(b"\x00")),
+        )
+
+    def test_eight(self) -> None:
+        self.assertTupleEqual(
+            ("[...]byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}", False),
+            golang_common.bytes_literal(bytearray(b"\x00\x01\x02\x03\x04\x05\x06\x07")),
+        )
+
+    def test_nine(self) -> None:
+        code, multiline = golang_common.bytes_literal(
+            bytearray(b"\x00\x01\x02\x03\x04\x05\x06\x07\x08")
+        )
+
+        self.assertEqual(
+            """\
+[...]byte {
+\t0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+\t0x08
+}""",
+            code,
+        )
+        self.assertTrue(multiline)
+
+    def test_sixteen(self) -> None:
+        code, multiline = golang_common.bytes_literal(
+            bytearray(
+                b"\x00\x01\x02\x03\x04\x05\x06\x07" b"\x08\x09\x10\x11\x12\x13\x14\x15"
+            )
+        )
+
+        self.assertEqual(
+            """\
+[...]byte {
+\t0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+\t0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15
+}""",
+            code,
+        )
+
+        self.assertTrue(multiline)
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/golang/test_main.py

@@ -0,0 +1,128 @@
+# 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" / "golang" / "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.GOLANG,
+                    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/common.go"),
+                    pathlib.Path("constants/constants.go"),
+                    pathlib.Path("enhancing/enhancing.go"),
+                    pathlib.Path("jsonization/jsonization.go"),
+                    pathlib.Path("reporting/reporting.go"),
+                    pathlib.Path("stringification/stringification.go"),
+                    pathlib.Path("types/types.go"),
+                    pathlib.Path("verification/verification.go"),
+                    pathlib.Path("xmlization/xmlization.go"),
+                ]:
+                    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/infer_for_schema/common.py

@@ -0,0 +1,47 @@
+"""Provide functions shared among the tests."""
+from typing import Tuple, MutableMapping
+
+import tests.common
+from aas_core_codegen import intermediate, infer_for_schema
+from aas_core_codegen.common import Identifier
+
+
+def parse_to_symbol_table_and_something_cls(
+    source: str,
+) -> Tuple[intermediate.SymbolTable, intermediate.ClassUnion]:
+    """
+    Parse the ``source``.
+
+    Return the symbol table and our type corresponding to the class ``Something``
+    in the ``source``.
+    """
+    symbol_table, error = tests.common.translate_source_to_intermediate(source=source)
+    assert error is None, tests.common.most_underlying_messages(error)
+    assert symbol_table is not None
+    something_cls = symbol_table.must_find_class(Identifier("Something"))
+
+    return symbol_table, something_cls
+
+
+def parse_to_symbol_table_and_something_cls_and_constraints_by_class(
+    source: str,
+) -> Tuple[
+    intermediate.SymbolTable,
+    intermediate.ClassUnion,
+    MutableMapping[intermediate.ClassUnion, infer_for_schema.ConstraintsByProperty],
+]:
+    """
+    Parse the ``source``.
+
+    Return the symbol table and our type corresponding to the class ``Something``
+    in the ``source`` as well as the inferred constraints mapped by classes.
+    """
+    symbol_table, something_cls = parse_to_symbol_table_and_something_cls(source=source)
+
+    constraints_by_class, error = infer_for_schema.infer_constraints_by_class(
+        symbol_table=symbol_table
+    )
+    assert error is None, tests.common.most_underlying_messages(error)
+    assert constraints_by_class is not None
+
+    return symbol_table, something_cls, constraints_by_class