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

dev/tests/cpp/test_verification.py

@@ -0,0 +1,189 @@
+# pylint: disable=missing-docstring
+
+import unittest
+from typing import List
+
+from aas_core_codegen.common import Stripped, Identifier
+from aas_core_codegen.cpp.verification import _generate as cpp_verification_generate
+from aas_core_codegen.intermediate import type_inference as intermediate_type_inference
+from tests import common as tests_common
+
+
+class Test_against_recorded(unittest.TestCase):
+    def test_optional_vector_in_invariant_not_deferenced(self) -> None:
+        # NOTE (mristin):
+        # This is a regression test where we check that an optional list without
+        # implication is not de-referenced in the invariant's transpiled code.
+
+        source = """\
+class Item:
+    value: str
+    
+    def __init__(self, value: str) -> None:
+        self.value = value
+
+@verification
+@implementation_specific
+def check_something(value: Optional[List[Item]]) -> bool:
+    pass
+
+@invariant(
+    lambda self:
+    check_something(self.value),
+    "Some description"
+)
+class Something:
+    value: Optional[List[Item]]
+    
+    def __init__(self, value: Optional[List[Item]] = None) -> None:
+        self.value = value
+        
+__version__ = "dummy"
+__xml_namespace__ = "https://dummy.com"
+"""
+
+        symbol_table = tests_common.must_translate_source_to_intermediate(source=source)
+
+        base_environment = intermediate_type_inference.populate_base_environment(
+            symbol_table=symbol_table
+        )
+
+        something_cls = symbol_table.must_find_concrete_class(
+            name=Identifier("Something")
+        )
+
+        environment = intermediate_type_inference.MutableEnvironment(
+            parent=base_environment
+        )
+        environment.set(
+            identifier=Identifier("self"),
+            type_annotation=intermediate_type_inference.OurTypeAnnotation(
+                our_type=something_cls
+            ),
+        )
+
+        blocks = []  # type: List[Stripped]
+        for invariant in something_cls.invariants:
+            (
+                condition_expr,
+                error,
+            ) = cpp_verification_generate._transpile_class_invariant(
+                invariant=invariant, symbol_table=symbol_table, environment=environment
+            )
+            assert error is None, (
+                f"Unexpected generation error for an invariant: "
+                f"{tests_common.most_underlying_messages(error)}"
+            )
+            assert condition_expr is not None
+
+            blocks.append(condition_expr)
+
+        assert len(blocks) == 1, (
+            f"Expected only a single block for a single invariant "
+            f"in the class {something_cls.name!r}"
+        )
+
+        # NOTE (mristin):
+        # The implementation of ``CheckSomething`` needs to deal with the optional
+        # values. As soon as something is optional in C++, it will be provided to
+        # the function as-is. This is intentional.
+        self.assertEqual(
+            """\
+CheckSomething(
+  instance_->value()
+)""",
+            blocks[0],
+        )
+
+    def test_optional_in_invariant_dereferenced_if_certainly_not_null(
+        self,
+    ) -> None:
+        # NOTE (mristin):
+        # This is a regression test where we check that an optional value is correctly
+        # de-referenced in the invariant's transpiled code if type inference determines
+        # that it is certainly not null.
+
+        source = """\
+class Item:
+    value: str
+
+    def __init__(self, value: str) -> None:
+        self.value = value
+
+@verification
+@implementation_specific
+def check_something(value: Optional[List[Item]]) -> bool:
+    pass
+
+@invariant(
+    lambda self:
+    (self.value is None) or check_something(self.value),
+    "Some description"
+)
+class Something:
+    value: Optional[List[Item]]
+
+    def __init__(self, value: Optional[List[Item]] = None) -> None:
+        self.value = value
+
+__version__ = "dummy"
+__xml_namespace__ = "https://dummy.com"
+"""
+
+        symbol_table = tests_common.must_translate_source_to_intermediate(source=source)
+
+        base_environment = intermediate_type_inference.populate_base_environment(
+            symbol_table=symbol_table
+        )
+
+        something_cls = symbol_table.must_find_concrete_class(
+            name=Identifier("Something")
+        )
+
+        environment = intermediate_type_inference.MutableEnvironment(
+            parent=base_environment
+        )
+        environment.set(
+            identifier=Identifier("self"),
+            type_annotation=intermediate_type_inference.OurTypeAnnotation(
+                our_type=something_cls
+            ),
+        )
+
+        blocks = []  # type: List[Stripped]
+        for invariant in something_cls.invariants:
+            (
+                condition_expr,
+                error,
+            ) = cpp_verification_generate._transpile_class_invariant(
+                invariant=invariant, symbol_table=symbol_table, environment=environment
+            )
+            assert error is None, (
+                f"Unexpected generation error for an invariant: "
+                f"{tests_common.most_underlying_messages(error)}"
+            )
+            assert condition_expr is not None
+
+            blocks.append(condition_expr)
+
+        assert len(blocks) == 1, (
+            f"Expected only a single block for a single invariant "
+            f"in the class {something_cls.name!r}"
+        )
+
+        # NOTE (mristin):
+        # If we know that the value is not optional, we explicitly de-reference it.
+        self.assertEqual(
+            """\
+(
+  (!(instance_->value().has_value()))
+  || CheckSomething(
+    (*(instance_->value()))
+  )
+)""",
+            blocks[0],
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/cpp/test_yielding.py

@@ -0,0 +1,225 @@
+# pylint: disable=missing-docstring
+
+import unittest
+
+from aas_core_codegen.common import Identifier
+from aas_core_codegen.yielding import (
+    flow as yielding_flow,
+)
+from aas_core_codegen.cpp import yielding as cpp_yielding
+
+
+class TestExecuteBody(unittest.TestCase):
+    def test_empty(self) -> None:
+        code = cpp_yielding.generate_execute_body(
+            flow=[], state_member=Identifier("state_")
+        )
+        self.assertEqual("// Intentionally empty.", code)
+
+    def test_inspired_by_verificator(self) -> None:
+        # NOTE (mristin, 2023-10-22):
+        # We test inspired by a real-world example from C++ code generation so that
+        # we can check whether the resulting code is readable.
+        #
+        # Hence, we test with two invariants and two constrained primitive properties
+        # so that the example is complex enough.
+        code = cpp_yielding.generate_execute_body(
+            flow=[
+                yielding_flow.IfFalse(
+                    condition="CheckInvariant0()",
+                    body=[
+                        yielding_flow.command_from_text(
+                            "error_ = ErrorForInvariant0();"
+                        ),
+                        yielding_flow.Yield(),
+                    ],
+                ),
+                yielding_flow.IfFalse(
+                    condition="CheckInvariant1()",
+                    body=[
+                        yielding_flow.command_from_text(
+                            "error_ = ErrorForInvariant1();"
+                        ),
+                        yielding_flow.Yield(),
+                    ],
+                ),
+                yielding_flow.IfTrue(
+                    condition="instance_.prop0.HasValue()",
+                    body=[
+                        yielding_flow.command_from_text(
+                            """\
+verification = VerifyConstrainedPrimitive(instance_.prop0.Value());
+iterator_ = verification.Begin();
+iterator_end_ = verification.End();"""
+                        ),
+                        yielding_flow.For(
+                            condition="iterator_ != iterator_end_",
+                            iteration="++iterator_",
+                            body=[
+                                yielding_flow.command_from_text("error_ = *iterator_;"),
+                                yielding_flow.Yield(),
+                            ],
+                        ),
+                        yielding_flow.command_from_text(
+                            """\
+iterator_.reset();
+iterator_end_.reset();"""
+                        ),
+                    ],
+                ),
+                yielding_flow.IfTrue(
+                    condition="instance_.prop1.HasValue()",
+                    body=[
+                        yielding_flow.command_from_text(
+                            """\
+verification = VerifyConstrainedPrimitive(instance_.prop1.Value());
+iterator_ = verification.Begin();
+iterator_end_ = verification.End();"""
+                        ),
+                        yielding_flow.For(
+                            condition="iterator_ != iterator_end_",
+                            iteration="++iterator_",
+                            body=[
+                                yielding_flow.command_from_text("error_ = *iterator_;"),
+                                yielding_flow.Yield(),
+                            ],
+                        ),
+                        yielding_flow.command_from_text(
+                            """\
+iterator_.reset();
+iterator_end_.reset();"""
+                        ),
+                    ],
+                ),
+                yielding_flow.command_from_text(
+                    """\
+error_.Reset();
+Finalize();"""
+                ),
+            ],
+            state_member=Identifier("state_"),
+        )
+
+        self.maxDiff = None
+        self.assertEqual(
+            """\
+while (true) {
+  switch (state_) {
+    case 0: {
+      if (CheckInvariant0()) {
+        state_ = 1;
+        continue;
+      }
+
+      error_ = ErrorForInvariant0();
+
+      state_ = 1;
+      return;
+    }
+
+    case 1: {
+      if (CheckInvariant1()) {
+        state_ = 2;
+        continue;
+      }
+
+      error_ = ErrorForInvariant1();
+
+      state_ = 2;
+      return;
+    }
+
+    case 2: {
+      if (!(instance_.prop0.HasValue())) {
+        state_ = 6;
+        continue;
+      }
+
+      verification = VerifyConstrainedPrimitive(instance_.prop0.Value());
+      iterator_ = verification.Begin();
+      iterator_end_ = verification.End();
+    }
+
+    case 3: {
+      if (!(iterator_ != iterator_end_)) {
+        state_ = 5;
+        continue;
+      }
+
+      error_ = *iterator_;
+
+      state_ = 4;
+      return;
+    }
+
+    case 4: {
+      ++iterator_
+
+      state_ = 3;
+      continue;
+    }
+
+    case 5: {
+      iterator_.reset();
+      iterator_end_.reset();
+    }
+
+    case 6: {
+      if (!(instance_.prop1.HasValue())) {
+        state_ = 10;
+        continue;
+      }
+
+      verification = VerifyConstrainedPrimitive(instance_.prop1.Value());
+      iterator_ = verification.Begin();
+      iterator_end_ = verification.End();
+    }
+
+    case 7: {
+      if (!(iterator_ != iterator_end_)) {
+        state_ = 9;
+        continue;
+      }
+
+      error_ = *iterator_;
+
+      state_ = 8;
+      return;
+    }
+
+    case 8: {
+      ++iterator_
+
+      state_ = 7;
+      continue;
+    }
+
+    case 9: {
+      iterator_.reset();
+      iterator_end_.reset();
+    }
+
+    case 10: {
+      error_.Reset();
+      Finalize();
+
+      // We invalidate the state since we reached the end of the routine.
+      state_ = 11;
+      return;
+    }
+
+    default:
+      throw std::logic_error(
+        common::Concat(
+          "Invalid state_: ",
+          std::to_string(state_)
+        )
+      );
+  }
+}""",
+            code,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/csharp/live_test_main.py

@@ -0,0 +1,109 @@
+"""
+Transpile the meta-model into C# and compile them into a project.
+
+This live tests expects dotnet to be installed on the machine.
+"""
+import io
+import os
+import pathlib
+import subprocess
+import sys
+import tempfile
+import textwrap
+
+import aas_core_codegen.main
+import tests.common
+
+
+def main() -> int:
+    """Execute the main routine."""
+    print("Running dotnet --version to check that dotnet is available...")
+    exit_code = subprocess.call(
+        ["dotnet", "--version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+    )
+    if exit_code != 0:
+        print(
+            f"Failed to execute ``dotnet --version`` "
+            f"with the exit code {exit_code}. Is dotnet installed?",
+            file=sys.stderr,
+        )
+        return 1
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        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
+
+            output_dir = pathlib.Path(tmp_dir) / case_dir.name
+
+            print(
+                f"Generating the files based on the case {case_dir} "
+                f"to: {output_dir} ..."
+            )
+
+            output_dir.mkdir(exist_ok=True, parents=True)
+
+            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
+            )
+
+            assert (
+                stderr.getvalue() == ""
+            ), f"Expected no stderr on valid models, but got:\n{stderr.getvalue()}"
+
+            assert (
+                return_code == 0
+            ), f"Expected return code 0 on valid models, but got: {return_code}"
+
+            print("Generating the .csproj file...")
+            csproj_pth = output_dir / "SomeProject.csproj"
+            csproj_pth.write_text(
+                textwrap.dedent(
+                    """\
+                <Project Sdk="Microsoft.NET.Sdk">
+                    <PropertyGroup>
+                        <TargetFramework>net6.0</TargetFramework>
+                        <Nullable>enable</Nullable>
+                        <Configurations>Debug;Release;DebugSlow</Configurations>
+                        <Platforms>AnyCPU</Platforms>
+                        <LangVersion>8</LangVersion>
+                    </PropertyGroup>
+                </Project>
+                """
+                ),
+                encoding="utf-8",
+            )
+
+            print("Calling dotnet build...")
+            exit_code = subprocess.call(["dotnet", "build", "."], cwd=str(output_dir))
+            if exit_code != 0:
+                print(
+                    f"ERROR: Expected the build to succeed, "
+                    f"but got exit code: {exit_code}",
+                    file=sys.stderr,
+                )
+                return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

dev/tests/csharp/test_common.py

@@ -0,0 +1,28 @@
+# pylint: disable=missing-docstring
+
+import unittest
+
+import aas_core_codegen.csharp.common as csharp_common
+
+
+class TestStringLiteral(unittest.TestCase):
+    def test_empty(self) -> None:
+        self.assertEqual('""', csharp_common.string_literal(""))
+
+    def test_identifier(self) -> None:
+        self.assertEqual('"something"', csharp_common.string_literal("something"))
+
+    def test_single_quote(self) -> None:
+        self.assertEqual('"some\'thing"', csharp_common.string_literal("some'thing"))
+
+    def test_double_quotes(self) -> None:
+        self.assertEqual('"some\\"thing"', csharp_common.string_literal('some"thing'))
+
+    def test_special_chars(self) -> None:
+        self.assertEqual(
+            '"some\\n\\\\thing"', csharp_common.string_literal("some\n\\thing")
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()