baldertest 0.1.1__tar.gz → 0.1.2__tar.gz

{baldertest-0.1.1 → baldertest-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baldertest
-Version: 0.1.1
+Version: 0.1.2
 Summary: balder: reusable scenario based test framework
 Home-page: https://docs.balder.dev
 Author: Max Stahlschmidt and others

{baldertest-0.1.1 → baldertest-0.1.2}/src/_balder/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.1'
-__version_tuple__ = version_tuple = (0, 1, 1)
+__version__ = version = '0.1.2'
+__version_tuple__ = version_tuple = (0, 1, 2)
 
-__commit_id__ = commit_id = 'ga69ecd731'
+__commit_id__ = commit_id = 'g86938bea8'

{baldertest-0.1.1 → baldertest-0.1.2}/src/_balder/executor/executor_tree.py

@@ -62,9 +62,10 @@ class ExecutorTree(BasicExecutableExecutor):
             self.update_inner_feature_reference_in_all_setups()
 
     def _body_execution(self, show_discarded):
-        for cur_setup_executor in self.get_setup_executors():
+        for cur_setup_executor in self.get_setup_executors(return_discarded=show_discarded):
             prev_mark = cur_setup_executor.prev_mark
-            if cur_setup_executor.has_runnable_tests(show_discarded) or cur_setup_executor.has_skipped_tests():
+            if cur_setup_executor.has_runnable_tests(consider_discarded_too=show_discarded) \
+                    or cur_setup_executor.has_skipped_tests():
                 cur_setup_executor.execute(show_discarded=show_discarded)
             elif prev_mark == PreviousExecutorMark.SKIP:
                 cur_setup_executor.set_result_for_whole_branch(ResultState.SKIP)
@@ -78,17 +79,30 @@ class ExecutorTree(BasicExecutableExecutor):
 
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
-    def get_setup_executors(self) -> List[SetupExecutor]:
-        """returns all setup executors of this tree"""
-        return self._setup_executors
+    def get_setup_executors(self, return_discarded=False) -> List[SetupExecutor]:
+        """
+        returns all setup executors of this tree
 
-    def get_all_scenario_executors(self) -> List[ScenarioExecutor]:
+        :param return_discarded: True if the method should return discarded variations too
+
+        :return: a list of relevant :class:`SetupExecutor`
+        """
+        if return_discarded:
+            return self._setup_executors
+
+        return [
+            cur_setup_executor
+            for cur_setup_executor in self._setup_executors
+            if len(cur_setup_executor.get_scenario_executors(return_discarded=False)) > 0
+        ]
+
+    def get_all_scenario_executors(self, return_discarded=False) -> List[ScenarioExecutor]:
         """
         returns a list with all scenario executors
         """
         all_scenario_executor = []
-        for cur_setup_executor in self.get_setup_executors():
-            all_scenario_executor += cur_setup_executor.get_scenario_executors()
+        for cur_setup_executor in self.get_setup_executors(return_discarded=return_discarded):
+            all_scenario_executor += cur_setup_executor.get_scenario_executors(return_discarded=return_discarded)
         return all_scenario_executor
 
     def get_all_variation_executors(self, return_discarded=False) -> List[VariationExecutor]:
@@ -96,7 +110,7 @@ class ExecutorTree(BasicExecutableExecutor):
         returns a list with all variation executors
         """
         all_variation_executor = []
-        for cur_scenario_executor in self.get_all_scenario_executors():
+        for cur_scenario_executor in self.get_all_scenario_executors(return_discarded=return_discarded):
             all_variation_executor += cur_scenario_executor.get_variation_executors(return_discarded=return_discarded)
         return all_variation_executor
 
@@ -136,9 +150,9 @@ class ExecutorTree(BasicExecutableExecutor):
 
     def cleanup_empty_executor_branches(self, consider_discarded=False):
         to_remove_executor = []
-        for cur_setup_executor in self.get_setup_executors():
+        for cur_setup_executor in self.get_setup_executors(return_discarded=consider_discarded):
             cur_setup_executor.cleanup_empty_executor_branches(consider_discarded=consider_discarded)
-            if len(cur_setup_executor.get_scenario_executors()) == 0:
+            if len(cur_setup_executor.get_scenario_executors(return_discarded=consider_discarded)) == 0:
                 # remove this whole executor because it has no children anymore
                 to_remove_executor.append(cur_setup_executor)
         for cur_setup_executor in to_remove_executor:
@@ -169,7 +183,7 @@ class ExecutorTree(BasicExecutableExecutor):
         print_line(start_text)
         # check if there exists runnable elements
         runnables = [cur_exec.has_runnable_tests(consider_discarded_too=show_discarded)
-                     for cur_exec in self.get_setup_executors()]
+                     for cur_exec in self.get_setup_executors(return_discarded=show_discarded)]
         one_or_more_runnable_setups = None if len(runnables) == 0 else max(runnables)
         if one_or_more_runnable_setups:
             super().execute(show_discarded=show_discarded)
@@ -189,8 +203,8 @@ class ExecutorTree(BasicExecutableExecutor):
     def print_tree(self, show_discarded=False) -> None:
         """this method is an auxiliary method which outputs the entire tree"""
         print("RESOLVING OVERVIEW", end="\n\n")
-        for cur_setup_executor in self.get_setup_executors():
-            for cur_scenario_executor in cur_setup_executor.get_scenario_executors():
+        for cur_setup_executor in self.get_setup_executors(return_discarded=show_discarded):
+            for cur_scenario_executor in cur_setup_executor.get_scenario_executors(return_discarded=show_discarded):
                 for cur_variation_executor in cur_scenario_executor.get_variation_executors(
                         return_discarded=show_discarded):
                     applicable = cur_variation_executor.prev_mark != PreviousExecutorMark.DISCARDED

{baldertest-0.1.1 → baldertest-0.1.2}/src/_balder/executor/scenario_executor.py

@@ -99,7 +99,8 @@ class ScenarioExecutor(BasicExecutableExecutor):
     def _body_execution(self, show_discarded):
         for cur_variation_executor in self.get_variation_executors(return_discarded=show_discarded):
             prev_mark = cur_variation_executor.prev_mark
-            if cur_variation_executor.has_runnable_tests() or cur_variation_executor.has_skipped_tests():
+            if cur_variation_executor.has_runnable_tests(consider_discarded_too=show_discarded) \
+                    or cur_variation_executor.has_skipped_tests():
                 cur_variation_executor.execute(show_discarded=show_discarded)
             elif prev_mark == PreviousExecutorMark.SKIP:
                 cur_variation_executor.set_result_for_whole_branch(ResultState.SKIP)

{baldertest-0.1.1 → baldertest-0.1.2}/src/_balder/executor/setup_executor.py

@@ -79,9 +79,10 @@ class SetupExecutor(BasicExecutableExecutor):
         print(f"SETUP {self.base_setup_class.__class__.__name__}")
 
     def _body_execution(self, show_discarded):
-        for cur_scenario_executor in self.get_scenario_executors():
+        for cur_scenario_executor in self.get_scenario_executors(return_discarded=show_discarded):
             prev_mark = cur_scenario_executor.prev_mark
-            if cur_scenario_executor.has_runnable_tests(show_discarded) or cur_scenario_executor.has_skipped_tests():
+            if cur_scenario_executor.has_runnable_tests(consider_discarded_too=show_discarded) \
+                    or cur_scenario_executor.has_skipped_tests():
                 cur_scenario_executor.execute(show_discarded=show_discarded)
             elif prev_mark == PreviousExecutorMark.SKIP:
                 cur_scenario_executor.set_result_for_whole_branch(ResultState.SKIP)
@@ -123,13 +124,26 @@ class SetupExecutor(BasicExecutableExecutor):
                     # object
                     setattr(cur_feature, cur_ref_feature_name, replacing_candidate)
 
-    def get_scenario_executors(self) -> List[ScenarioExecutor]:
-        """returns a list with all scenario executors that belongs to this setup executor"""
-        return self._scenario_executors
+    def get_scenario_executors(self, return_discarded=False) -> List[ScenarioExecutor]:
+        """
+        returns a list with all scenario executors that belongs to this setup executor
+
+        :param return_discarded: True if the method should return discarded variations too
+
+        :return: a list of relevant :class:`ScenarioExecutor`
+        """
+        if return_discarded:
+            return self._scenario_executors
+
+        return [
+            cur_scenario_executor
+            for cur_scenario_executor in self._scenario_executors
+            if len(cur_scenario_executor.get_variation_executors(return_discarded=False)) > 0
+        ]
 
     def cleanup_empty_executor_branches(self, consider_discarded=False):
         to_remove_executor = []
-        for cur_scenario_executor in self.get_scenario_executors():
+        for cur_scenario_executor in self.get_scenario_executors(return_discarded=consider_discarded):
             cur_scenario_executor.cleanup_empty_executor_branches(consider_discarded=consider_discarded)
             if len(cur_scenario_executor.get_variation_executors(return_discarded=consider_discarded)) == 0:
                 # remove this whole executor because it has no children anymore

{baldertest-0.1.1 → baldertest-0.1.2}/src/_balder/solver.py

@@ -219,9 +219,6 @@ class Solver:
                 variation_executor = VariationExecutor(device_mapping=cur_device_mapping, parent=scenario_executor)
                 variation_executor.verify_applicability()
 
-                if not variation_executor.can_be_applied():
-                    continue
-
                 scenario_executor.add_variation_executor(variation_executor)
 
                 for cur_testcase in scenario_executor.base_scenario_controller.get_all_test_methods():

{baldertest-0.1.1 → baldertest-0.1.2}/src/baldertest.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baldertest
-Version: 0.1.1
+Version: 0.1.2
 Summary: balder: reusable scenario based test framework
 Home-page: https://docs.balder.dev
 Author: Max Stahlschmidt and others

{baldertest-0.1.1 → baldertest-0.1.2}/src/baldertest.egg-info/SOURCES.txt

@@ -226,6 +226,30 @@ tests/basic/test_2_msg_transmission/env/setups/__init__.py
 tests/basic/test_2_msg_transmission/env/setups/features_setup.py
 tests/basic/test_2_msg_transmission/env/setups/setup_queue_alice_to_bob.py
 tests/basic/test_2_msg_transmission/env/setups/setup_var_alice_to_bob.py
+tests/cli/__init__.py
+tests/cli/test_0_args/__init__.py
+tests/cli/test_0_args/test_0_collect_only.py
+tests/cli/test_0_args/test_0_collect_only_and_show_discarded.py
+tests/cli/test_0_args/test_0_resolve_only.py
+tests/cli/test_0_args/test_0_resolve_only_and_show_discarded.py
+tests/cli/test_0_args/test_0_show_discarded.py
+tests/cli/test_0_args/env/__init__.py
+tests/cli/test_0_args/env/balderglob.py
+tests/cli/test_0_args/env/lib/__init__.py
+tests/cli/test_0_args/env/lib/connections.py
+tests/cli/test_0_args/env/lib/features.py
+tests/cli/test_0_args/env/lib/utils.py
+tests/cli/test_0_args/env/scenarios/__init__.py
+tests/cli/test_0_args/env/scenarios/scenario_a.py
+tests/cli/test_0_args/env/scenarios/scenario_b.py
+tests/cli/test_0_args/env/setups/__init__.py
+tests/cli/test_0_args/env/setups/setup_a.py
+tests/cli/test_0_args/env/setups/setup_b.py
+tests/cli/test_0_args/env/setups/setup_features/__init__.py
+tests/cli/test_0_args/env/setups/setup_features/feature_i.py
+tests/cli/test_0_args/env/setups/setup_features/feature_ii.py
+tests/cli/test_0_args/env/setups/setup_features/feature_iii.py
+tests/cli/test_0_args/env/setups/setup_features/feature_iv.py
 tests/collecting/__init__.py
 tests/collecting/test_0_inherit_scenario/__init__.py
 tests/collecting/test_0_inherit_scenario/test_0_inherit_scenario.py
@@ -1389,6 +1413,7 @@ tests/test_utilities/__init__.py
 tests/test_utilities/base_01_envtester_methvar_class.py
 tests/test_utilities/base_0_envtester_class.py
 tests/test_utilities/observer_compare.py
+tests/test_utilities/output_compare.py
 tests/vdevice/__init__.py
 tests/vdevice/classbased/__init__.py
 tests/vdevice/classbased/test_0_scenariomap_scenariodef_scenariofeat/__init__.py

baldertest-0.1.2/tests/cli/test_0_args/test_0_collect_only.py

@@ -0,0 +1,30 @@
+import re
+from _balder.balder_session import BalderSession
+from ...test_utilities.base_0_envtester_class import Base0EnvtesterClass
+
+
+class Test0CollectOnly(Base0EnvtesterClass):
+    """
+    This testcase executes the basic ENV example with a specific command line argument ``--collect-only``.
+
+    The test checks that no tests are executed and the printed information is like expected.
+    """
+
+    @property
+    def cmd_args(self):
+        return ['--collect-only']
+
+    @property
+    def expected_data(self) -> tuple:
+        return tuple()
+
+    def validate_printed_output(self, stdout: str) -> bool:
+        assert self._check_header_of_stdout(stdout, 2, 2), \
+            f"problems within header output"
+        assert len(stdout.splitlines()) == 5, f"detect more output lines (={len(stdout.splitlines())}) than expected"
+        return True
+
+    @staticmethod
+    def validate_finished_session(session: BalderSession):
+        # make sure that  no executor tree was created
+        assert session.executor_tree is None, f"executor tree is not None"

baldertest-0.1.2/tests/cli/test_0_args/test_0_collect_only_and_show_discarded.py

@@ -0,0 +1,32 @@
+from _balder.testresult import ResultState
+from _balder.balder_session import BalderSession
+from ...test_utilities.base_0_envtester_class import Base0EnvtesterClass
+
+
+class Test0CollectOnlyAndShowDiscarded(Base0EnvtesterClass):
+    """
+    This testcase executes the basic ENV example with a specific command line argument
+    ``--collect-only --show-discarded``.
+
+    The test checks that no tests are executed and the printed information is like expected. It makes sure, that the
+    ``--show-discarded`` argument is ignored.
+    """
+
+    @property
+    def cmd_args(self):
+        return ['--collect-only', '--show-discarded']
+
+    @property
+    def expected_data(self) -> tuple:
+        return tuple()
+
+    def validate_printed_output(self, stdout: str) -> bool:
+        assert self._check_header_of_stdout(stdout, 2, 2), \
+            f"problems within header output"
+        assert len(stdout.splitlines()) == 5, f"detect more output lines (={len(stdout.splitlines())}) than expected"
+        return True
+
+    @staticmethod
+    def validate_finished_session(session: BalderSession):
+        # make sure that  no executor tree was created
+        assert session.executor_tree is None, f"executor tree is not None"

baldertest-0.1.2/tests/cli/test_0_args/test_0_resolve_only.py

@@ -0,0 +1,54 @@
+import re
+
+from _balder.testresult import ResultState
+from _balder.balder_session import BalderSession
+from ...test_utilities.base_0_envtester_class import Base0EnvtesterClass
+
+
+class Test0ResolveOnly(Base0EnvtesterClass):
+    """
+    This testcase executes the basic ENV example with a specific command line argument ``--resolve-only``.
+
+    The test checks that no tests are executed and the printed information is like expected.
+    """
+
+    @property
+    def cmd_args(self):
+        return ['--resolve-only']
+
+    @property
+    def expected_data(self) -> tuple:
+        return tuple()
+
+    def validate_printed_output(self, stdout: str) -> bool:
+        assert self._check_header_of_stdout(stdout, 2, 2, 2), f"problems within header output"
+        remaining_lines = stdout.splitlines()
+        assert remaining_lines[7] == "RESOLVING OVERVIEW"
+        split_blocks = "\n".join(remaining_lines[8:]).strip().split('\n\n')
+        assert len(split_blocks) == 2
+
+        expected_blocks = [
+"""++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++ [APPLICABLE] Scenario `ScenarioB` <-> Setup `SetupB`
++    ScenarioB.ScenarioDevice3 = SetupB.SetupDevice3
++    ScenarioB.ScenarioDevice4 = SetupB.SetupDevice4
++    -> Testcase<ScenarioB.test_b_1>
++    -> Testcase<ScenarioB.test_b_2>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++""",
+"""++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++ [APPLICABLE] Scenario `ScenarioA` <-> Setup `SetupA`
++    ScenarioA.ScenarioDevice1 = SetupA.SetupDevice1
++    ScenarioA.ScenarioDevice2 = SetupA.SetupDevice2
++    -> Testcase<ScenarioA.test_a_1>
++    -> Testcase<ScenarioA.test_a_2>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"""
+        ]
+
+        assert sorted(split_blocks) == sorted(expected_blocks), f"detect issues in blocks"
+        return True
+
+    @staticmethod
+    def validate_finished_session(session: BalderSession):
+        # check result states everywhere (have to be SUCCESS everywhere
+        assert session.executor_tree.executor_result == ResultState.NOT_RUN, \
+            "test session does not terminates with NOT_RUN"

baldertest-0.1.2/tests/cli/test_0_args/test_0_resolve_only_and_show_discarded.py

@@ -0,0 +1,110 @@
+import re
+
+from _balder.testresult import ResultState
+from _balder.balder_session import BalderSession
+from ...test_utilities.base_0_envtester_class import Base0EnvtesterClass
+
+
+class Test0ResolveOnlyAndShowDiscarded(Base0EnvtesterClass):
+    """
+    This testcase executes the basic ENV example with a specific command line argument
+    ``--resolve-only --show-discarded``.
+
+    The test checks that no tests are executed and the printed information is like expected. Additionally, it ensures
+    that all discarded tests are printed too and the reason why they were discarded is printed too.
+    """
+
+    @property
+    def cmd_args(self):
+        return ['--resolve-only', '--show-discarded']
+
+    @property
+    def expected_data(self) -> tuple:
+        return tuple()
+
+    def validate_printed_output(self, stdout: str) -> bool:
+        assert self._check_header_of_stdout(stdout, 2, 2, 2, expected_discarded=6), \
+            f"problems within header output"
+        remaining_lines = stdout.splitlines()
+        assert remaining_lines[7] == "RESOLVING OVERVIEW"
+        split_blocks = "\n".join(remaining_lines[8:]).strip().split('\n\n')
+        assert len(split_blocks) == 8
+
+        expected_blocks = [
+"""XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X [DISCARDED]  Scenario `ScenarioA` <-> Setup `SetupB`
+X    ScenarioA.ScenarioDevice1 = SetupB.SetupDevice3
+X    ScenarioA.ScenarioDevice2 = SetupB.SetupDevice4
+X    -> Testcase<ScenarioA.test_a_1>
+X    -> Testcase<ScenarioA.test_a_2>
+X
+X    DISCARDED BECAUSE `this variation can not be applicable because there was no setup feature implementation of `FeatureI` (used by scenario device `ScenarioDevice1`) in setup device `SetupDevice3``
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX""",
+"""XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X [DISCARDED]  Scenario `ScenarioA` <-> Setup `SetupB`
+X    ScenarioA.ScenarioDevice1 = SetupB.SetupDevice4
+X    ScenarioA.ScenarioDevice2 = SetupB.SetupDevice3
+X    -> Testcase<ScenarioA.test_a_1>
+X    -> Testcase<ScenarioA.test_a_2>
+X
+X    DISCARDED BECAUSE `this variation can not be applicable because there was no setup feature implementation of `FeatureI` (used by scenario device `ScenarioDevice1`) in setup device `SetupDevice4``
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX""",
+"""++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++ [APPLICABLE] Scenario `ScenarioB` <-> Setup `SetupB`
++    ScenarioB.ScenarioDevice3 = SetupB.SetupDevice3
++    ScenarioB.ScenarioDevice4 = SetupB.SetupDevice4
++    -> Testcase<ScenarioB.test_b_1>
++    -> Testcase<ScenarioB.test_b_2>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++""",
+"""XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X [DISCARDED]  Scenario `ScenarioB` <-> Setup `SetupB`
+X    ScenarioB.ScenarioDevice3 = SetupB.SetupDevice4
+X    ScenarioB.ScenarioDevice4 = SetupB.SetupDevice3
+X    -> Testcase<ScenarioB.test_b_1>
+X    -> Testcase<ScenarioB.test_b_2>
+X
+X    DISCARDED BECAUSE `this variation can not be applicable because there was no setup feature implementation of `FeatureIII` (used by scenario device `ScenarioDevice3`) in setup device `SetupDevice4``
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX""",
+"""++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++ [APPLICABLE] Scenario `ScenarioA` <-> Setup `SetupA`
++    ScenarioA.ScenarioDevice1 = SetupA.SetupDevice1
++    ScenarioA.ScenarioDevice2 = SetupA.SetupDevice2
++    -> Testcase<ScenarioA.test_a_1>
++    -> Testcase<ScenarioA.test_a_2>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++""",
+"""XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X [DISCARDED]  Scenario `ScenarioA` <-> Setup `SetupA`
+X    ScenarioA.ScenarioDevice1 = SetupA.SetupDevice2
+X    ScenarioA.ScenarioDevice2 = SetupA.SetupDevice1
+X    -> Testcase<ScenarioA.test_a_1>
+X    -> Testcase<ScenarioA.test_a_2>
+X
+X    DISCARDED BECAUSE `this variation can not be applicable because there was no setup feature implementation of `FeatureI` (used by scenario device `ScenarioDevice1`) in setup device `SetupDevice2``
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX""",
+"""XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X [DISCARDED]  Scenario `ScenarioB` <-> Setup `SetupA`
+X    ScenarioB.ScenarioDevice3 = SetupA.SetupDevice1
+X    ScenarioB.ScenarioDevice4 = SetupA.SetupDevice2
+X    -> Testcase<ScenarioB.test_b_1>
+X    -> Testcase<ScenarioB.test_b_2>
+X
+X    DISCARDED BECAUSE `this variation can not be applicable because there was no setup feature implementation of `FeatureIII` (used by scenario device `ScenarioDevice3`) in setup device `SetupDevice1``
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX""",
+"""XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+X [DISCARDED]  Scenario `ScenarioB` <-> Setup `SetupA`
+X    ScenarioB.ScenarioDevice3 = SetupA.SetupDevice2
+X    ScenarioB.ScenarioDevice4 = SetupA.SetupDevice1
+X    -> Testcase<ScenarioB.test_b_1>
+X    -> Testcase<ScenarioB.test_b_2>
+X
+X    DISCARDED BECAUSE `this variation can not be applicable because there was no setup feature implementation of `FeatureIII` (used by scenario device `ScenarioDevice3`) in setup device `SetupDevice2``
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"""
+        ]
+
+        assert sorted(split_blocks) == sorted(expected_blocks), f"detect issues in blocks"
+        return True
+
+    @staticmethod
+    def validate_finished_session(session: BalderSession):
+        assert session.executor_tree.executor_result == ResultState.NOT_RUN, \
+            "test session does not terminates with NOT_RUN"