baldertest 0.1.0b12__py3-none-any.whl → 0.1.0b13__py3-none-any.whl

_balder/executor/testcase_executor.py

@@ -9,15 +9,17 @@ from _balder.executor.basic_executable_executor import BasicExecutableExecutor
 from _balder.fixture_execution_level import FixtureExecutionLevel
 from _balder.previous_executor_mark import PreviousExecutorMark
 from _balder.testresult import ResultState, TestcaseResult
-from _balder.utils import inspect_method
+from _balder.utils.functions import get_method_type
+from _balder.utils.mixin_can_be_covered_by_executor import MixinCanBeCoveredByExecutor
 
 if TYPE_CHECKING:
+    from _balder.executor.scenario_executor import ScenarioExecutor
     from _balder.executor.variation_executor import VariationExecutor
     from _balder.fixture_manager import FixtureManager
     from _balder.scenario import Scenario
 
 
-class TestcaseExecutor(BasicExecutableExecutor):
+class TestcaseExecutor(BasicExecutableExecutor, MixinCanBeCoveredByExecutor):
     """
     A TestcaseExecutor class represents an actual single test that can be executed. It therefore references exactly to a
     test method of a scenario that can be executed on the specific setup this executor belongs to.
@@ -65,6 +67,10 @@ class TestcaseExecutor(BasicExecutableExecutor):
     def parent_executor(self) -> VariationExecutor:
         return self._parent_executor
 
+    @property
+    def scenario_executor(self) -> ScenarioExecutor:
+        return self.parent_executor.parent_executor
+
     @property
     def base_instance(self) -> object:
         """
@@ -99,15 +105,23 @@ class TestcaseExecutor(BasicExecutableExecutor):
 
     def _prepare_execution(self, show_discarded):
         print(f"      TEST {self.full_test_name_str} ", end='')
+
+    def _body_execution(self, show_discarded):
+        self.test_execution_time_sec = 0
+
         if self.should_be_skipped():
             self.body_result.set_result(ResultState.SKIP)
-            self.execution_time_sec = 0
-            print("[S]")
+            return
+        if self.should_be_ignored():
+            self.body_result.set_result(ResultState.NOT_RUN)
+            return
+        if self.is_covered_by():
+            self.body_result.set_result(ResultState.COVERED_BY)
+            return
 
-    def _body_execution(self, show_discarded):
         start_time = time.perf_counter()
         try:
-            _, func_type = inspect_method(self.base_testcase_callable)
+            func_type = get_method_type(self.base_testcase_obj.__class__, self.base_testcase_callable)
             all_args = self.get_all_test_method_args()
             if func_type == "staticmethod":
                 # testcase is a staticmethod - no special first attribute
@@ -151,6 +165,16 @@ class TestcaseExecutor(BasicExecutableExecutor):
             return True
         return False
 
+    def is_covered_by(self):
+        """returns true if the testcase is covered-by"""
+        return self.prev_mark == PreviousExecutorMark.COVERED_BY
+
+    def has_skipped_tests(self) -> bool:
+        return self.prev_mark == PreviousExecutorMark.SKIP
+
+    def has_covered_by_tests(self) -> bool:
+        return self.prev_mark == PreviousExecutorMark.COVERED_BY
+
     def cleanup_empty_executor_branches(self, consider_discarded=False):
         """
         This method searches the whole tree and removes branches where an executor item has no own children. It can
@@ -160,25 +184,17 @@ class TestcaseExecutor(BasicExecutableExecutor):
         """
 
     def get_covered_by_element(self) -> List[Union[Scenario, callable]]:
-        """
-        This method returns a list of elements where the whole scenario is covered from. This means, that the whole
-        test methods in this scenario are already be covered from every single element in the list.
-        """
-        all_covered_by_data = []
-        scenario_executor = self.parent_executor.parent_executor
-        scenario_class = scenario_executor.base_scenario_class
-        covered_by_dict_resolved = scenario_executor.get_covered_by_dict()
-        if self.base_testcase_callable in covered_by_dict_resolved.keys():
-            all_covered_by_data += covered_by_dict_resolved[self.base_testcase_callable]
-        if scenario_class in covered_by_dict_resolved.keys():
-            all_covered_by_data += covered_by_dict_resolved[scenario_class]
+        covered_by_dict = self.scenario_executor.base_scenario_controller.get_abs_covered_by_dict()
+        all_covered_by_data = covered_by_dict.get(self.base_testcase_callable.__name__, [])
+        # also add all scenario specified covered-by elements
+        all_covered_by_data.extend(covered_by_dict.get(None, []))
         return all_covered_by_data
 
     def get_all_test_method_args(self):
         """
         returns all kwargs values for the test method
         """
-        _, func_type = inspect_method(self.base_testcase_callable)
+        func_type = get_method_type(self.base_testcase_obj.__class__, self.base_testcase_callable)
         return self.fixture_manager.get_all_attribute_values(
             self,
             self.base_testcase_obj.__class__,

_balder/executor/unresolved_parametrized_testcase_executor.py

@@ -11,14 +11,16 @@ from _balder.executor.parametrized_testcase_executor import ParametrizedTestcase
 from _balder.parametrization import Parameter
 from _balder.previous_executor_mark import PreviousExecutorMark
 from _balder.testresult import BranchBodyResult
+from _balder.utils.mixin_can_be_covered_by_executor import MixinCanBeCoveredByExecutor
 
 if TYPE_CHECKING:
+    from _balder.executor.scenario_executor import ScenarioExecutor
     from _balder.executor.variation_executor import VariationExecutor
     from _balder.scenario import Scenario
     from _balder.setup import Setup
 
 
-class UnresolvedParametrizedTestcaseExecutor(BasicExecutor):
+class UnresolvedParametrizedTestcaseExecutor(BasicExecutor, MixinCanBeCoveredByExecutor):
     """
     This executor class represents a group of dynamically parametrized tests.
     """
@@ -37,9 +39,6 @@ class UnresolvedParametrizedTestcaseExecutor(BasicExecutor):
         # holds the specific static parameters for this unresolved group
         self._static_parameters = static_parameters if static_parameters is not None else {}
 
-        # holds the dynamically created testcase executors as soon as this executor is entered
-        self._testcase_executors = None
-
         # contains the result object for the BODY part of this branch
         self.body_result = BranchBodyResult(self)
 
@@ -47,14 +46,18 @@ class UnresolvedParametrizedTestcaseExecutor(BasicExecutor):
     def parent_executor(self) -> VariationExecutor:
         return self._parent_executor
 
+    @property
+    def scenario_executor(self) -> ScenarioExecutor:
+        return self.parent_executor.parent_executor
+
     @property
     def base_testcase_callable(self) -> callable:
         """returns the testcase function"""
         return self._base_testcase_callable
 
     @property
-    def all_child_executors(self) -> List[ParametrizedTestcaseExecutor]:
-        return self.get_testcase_executors()
+    def all_child_executors(self) -> None:
+        return None
 
     @property
     def base_testcase_obj(self) -> Scenario:
@@ -69,29 +72,11 @@ class UnresolvedParametrizedTestcaseExecutor(BasicExecutor):
         returns the base class instance to which this executor instance belongs"""
         return self._base_testcase_callable
 
-    @property
-    def parametrization_has_been_resolved(self) -> bool:
-        """returns true if the parametrization has been resolved"""
-        return self._testcase_executors is not None
-
-    def has_runnable_tests(self, consider_discarded_too=False) -> bool:
-        """
-        This method returns true if this executor element is runnable. The method returns true if this element has
-        `prev_mark=RUNNABLE` and minimum one of its children has `prev_mark=RUNNABLE` too.
-
-        :param consider_discarded_too: True if the method allows DISCARDED elements too
-        """
-        if self.parametrization_has_been_resolved:
-            return super().has_runnable_tests(consider_discarded_too=consider_discarded_too)
+    def has_skipped_tests(self) -> bool:
+        return self.prev_mark == PreviousExecutorMark.SKIP
 
-        allowed_prev_marks = [PreviousExecutorMark.RUNNABLE]
-
-        if consider_discarded_too:
-            allowed_prev_marks.append(PreviousExecutorMark.DISCARDED)
-
-        if self.prev_mark not in allowed_prev_marks:
-            return False
-        return True
+    def has_covered_by_tests(self) -> bool:
+        return self.prev_mark == PreviousExecutorMark.COVERED_BY
 
     def get_all_base_instances_of_this_branch(
             self, with_type: Type[Setup] | Type[Scenario] | Type[types.FunctionType],
@@ -105,43 +90,33 @@ class UnresolvedParametrizedTestcaseExecutor(BasicExecutor):
         return []
 
     def get_covered_by_element(self) -> List[Scenario | callable]:
-        """
-        This method returns a list of elements where the whole scenario is covered from. This means, that the whole
-        test methods in this scenario are already be covered from every single element in the list.
-        """
-        all_covered_by_data = []
-        scenario_executor = self.parent_executor.parent_executor
-        scenario_class = scenario_executor.base_scenario_class
-        covered_by_dict_resolved = scenario_executor.get_covered_by_dict()
-        if self.base_testcase_callable in covered_by_dict_resolved.keys():
-            all_covered_by_data += covered_by_dict_resolved[self.base_testcase_callable]
-        if scenario_class in covered_by_dict_resolved.keys():
-            all_covered_by_data += covered_by_dict_resolved[scenario_class]
+        covered_by_dict = self.scenario_executor.base_scenario_controller.get_abs_covered_by_dict()
+        all_covered_by_data = covered_by_dict.get(self.base_testcase_callable.__name__, [])
+        # also add all scenario specified covered-by elements
+        all_covered_by_data.extend(covered_by_dict.get(None, []))
         return all_covered_by_data
 
-    def get_testcase_executors(self) -> List[ParametrizedTestcaseExecutor | UnresolvedParametrizedTestcaseExecutor]:
-        """returns all sub testcase executors that belongs to this variation-executor"""
-        if self._testcase_executors is None:
-            return [self]
-        return self._testcase_executors
-
-    def resolve_dynamic_parametrization(self):
+    def get_resolved_parametrized_testcase_executors(self):
         """
         resolves the dynamic parametrization - should be called when setup features are active in the scenario
         """
-        self._testcase_executors = []
+        executors = []
 
         parametrization = self.get_parametrization()
-        if parametrization:
-            for cur_parametrization in parametrization:
-                self._testcase_executors.append(
-                    ParametrizedTestcaseExecutor(
-                        self._base_testcase_callable,
-                        parent=self.parent_executor,
-                        parametrization=cur_parametrization,
-                        unresolved_group_obj=self
-                    )
+
+        if not parametrization:
+            return []
+
+        for cur_parametrization in parametrization:
+            executors.append(
+                ParametrizedTestcaseExecutor(
+                    self._base_testcase_callable,
+                    parent=self.parent_executor,
+                    parametrization=cur_parametrization,
+                    unresolved_group_obj=self
                 )
+            )
+        return executors
 
     def get_parametrization(self) -> List[OrderedDict[str, Any]] | None:
         """

_balder/executor/variation_executor.py

@@ -171,7 +171,7 @@ class VariationExecutor(BasicExecutableExecutor):
             self.exchange_unmapped_vdevice_references()
             self.update_vdevice_referenced_feature_instances()
             self.set_conn_dependent_methods()
-            self.resolve_possible_parametrization()
+            self.resolve_and_exchange_unresolved_parametrization()
 
     def _body_execution(self, show_discarded):
         if show_discarded and not self.can_be_applied():
@@ -179,13 +179,10 @@ class VariationExecutor(BasicExecutableExecutor):
             return
 
         for cur_testcase_executor in self.get_testcase_executors():
-            if cur_testcase_executor.has_runnable_tests():
-
+            if (cur_testcase_executor.has_runnable_tests()
+                    or cur_testcase_executor.has_skipped_tests()
+                    or cur_testcase_executor.has_covered_by_tests()):
                 cur_testcase_executor.execute()
-            elif cur_testcase_executor.prev_mark == PreviousExecutorMark.SKIP:
-                cur_testcase_executor.set_result_for_whole_branch(ResultState.SKIP)
-            elif cur_testcase_executor.prev_mark == PreviousExecutorMark.COVERED_BY:
-                cur_testcase_executor.set_result_for_whole_branch(ResultState.COVERED_BY)
             else:
                 cur_testcase_executor.set_result_for_whole_branch(ResultState.NOT_RUN)
 
@@ -335,16 +332,9 @@ class VariationExecutor(BasicExecutableExecutor):
             return super().testsummary()
         return ResultSummary()
 
-    def get_testcase_executors(self) -> List[TestcaseExecutor]:
+    def get_testcase_executors(self) -> List[TestcaseExecutor | UnresolvedParametrizedTestcaseExecutor]:
         """returns all sub testcase executors that belongs to this variation-executor"""
-        result = []
-        for cur_executor in self._testcase_executors:
-            if (isinstance(cur_executor, UnresolvedParametrizedTestcaseExecutor) and
-                    cur_executor.parametrization_has_been_resolved):
-                result += cur_executor.get_testcase_executors()
-            else:
-                result.append(cur_executor)
-        return result
+        return self._testcase_executors.copy()
 
     def add_testcase_executor(self, testcase_executor: TestcaseExecutor | UnresolvedParametrizedTestcaseExecutor):
         """
@@ -388,12 +378,9 @@ class VariationExecutor(BasicExecutableExecutor):
             setup_dev: FeatureVDeviceMapping() for setup_dev in self.base_device_mapping.values()
         }
         for cur_scenario_device, cur_setup_device in self.base_device_mapping.items():
-            cur_setup_features = DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
 
-            all_assigned_setup_features = []
-            cur_scenario_device_features = \
-                DeviceController.get_for(cur_scenario_device).get_all_instantiated_feature_objects()
-            for cur_attr_name, cur_scenario_feature_obj in cur_scenario_device_features.items():
+            for cur_attr_name, cur_scenario_feature_obj in \
+                    DeviceController.get_for(cur_scenario_device).get_all_instantiated_feature_objects().items():
                 active_scenario_vdevice, mapped_scenario_device = cur_scenario_feature_obj.active_vdevice_device_mapping
 
                 cur_setup_feature_objs = self._get_matching_setup_features_for(
@@ -407,13 +394,14 @@ class VariationExecutor(BasicExecutableExecutor):
                         f'`{cur_scenario_device.__name__}`) in setup device `{cur_setup_device.__name__}`')
                 cur_setup_feature_obj = cur_setup_feature_objs[0]
 
+                all_abs_inner_vdevs_of_setup = \
+                    FeatureController.get_for(cur_setup_feature_obj.__class__).get_abs_inner_vdevice_classes()
+                used_setup_vdevice, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
+
                 if mapped_scenario_device is None:
                     # we have exactly one matching candidate, but also no vDevice mapping
                     # check if the matching candidate has a vDevice mapping
-                    _, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
-                    cleanup_feature_controller = FeatureController.get_for(cur_setup_feature_obj.__class__)
-                    if mapped_setup_device is None \
-                            and len(cleanup_feature_controller.get_abs_inner_vdevice_classes()) > 0:
+                    if mapped_setup_device is None and len(all_abs_inner_vdevs_of_setup) > 0:
                         # there is no vDevice mapping on scenario and no vDevice mapping on setup level, but the
                         # feature defined vDevices -> NOT APPLICABLE
                         logger.warning(
@@ -427,19 +415,14 @@ class VariationExecutor(BasicExecutableExecutor):
                             f'`{cur_scenario_feature_obj.__class__.__name__}` (used by scenario device '
                             f'`{cur_scenario_device.__name__}`) in setup device `{cur_setup_device.__name__}`')
 
-                all_assigned_setup_features.append(cur_setup_feature_obj)
                 if cur_attr_name not in feature_replacement[cur_scenario_device].attr_names:
-                    cleanup_feature_controller = FeatureController.get_for(cur_setup_feature_obj.__class__)
-
-                    used_setup_vdevice, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
 
                     # if there is a vDevice mapping on scenario level, but not on setup level, so update the
                     # VDevice-Device-Mapping there
                     if mapped_scenario_device is not None and mapped_setup_device is None:
                         # search the equivalent vDevice on setup level and use this one (we had not to check it,
                         # because check was already done in collector-stage)
-                        setup_vdevices = [cur_vdevice for cur_vdevice
-                                          in cleanup_feature_controller.get_abs_inner_vdevice_classes()
+                        setup_vdevices = [cur_vdevice for cur_vdevice in all_abs_inner_vdevs_of_setup
                                           if cur_vdevice.__name__ == active_scenario_vdevice.__name__]
                         used_setup_vdevice = setup_vdevices[0]
                         # set the mapping
@@ -463,21 +446,7 @@ class VariationExecutor(BasicExecutableExecutor):
                                                                  scenario_feature=cur_scenario_feature_obj,
                                                                  setup_feature=cur_setup_feature_obj)
 
-            # also add all setup features that are not assigned as autonomous features
-            for cur_setup_feature in cur_setup_features.values():
-                if cur_setup_feature not in all_assigned_setup_features:
-                    # determine free name
-                    idx = 0
-                    autonomous_name = None
-                    while (autonomous_name is None
-                           or autonomous_name in feature_replacement[cur_scenario_device].attr_names):
-                        autonomous_name = f"_autonomous_feat_{idx}"
-                        idx += 1
-                    feature_replacement[cur_scenario_device].add(
-                        attr_name=autonomous_name,
-                        scenario_feature=None,
-                        setup_feature=cur_setup_feature
-                    )
+            feature_replacement[cur_scenario_device].add_remaining_setup_features_as_autonomous(cur_setup_device)
 
         # set the result to internal properties
         self._feature_replacement = feature_replacement
@@ -902,8 +871,12 @@ class VariationExecutor(BasicExecutableExecutor):
 
                 cur_setup_feature_controller.set_active_method_variation(method_selection=method_var_selection)
 
-    def resolve_possible_parametrization(self):
+    def resolve_and_exchange_unresolved_parametrization(self):
         """resolves the parametrization if there are any :class:`UnresolvedParametrizedTestcaseExecutor` in the tree"""
+        replaced_executors = []
         for cur_child in self._testcase_executors:
             if isinstance(cur_child, UnresolvedParametrizedTestcaseExecutor):
-                cur_child.resolve_dynamic_parametrization()
+                replaced_executors.extend(cur_child.get_resolved_parametrized_testcase_executors())
+            else:
+                replaced_executors.append(cur_child)
+        self._testcase_executors = replaced_executors

_balder/feature.py

@@ -3,9 +3,10 @@ from typing import Type, Dict, Tuple, Union
 
 from _balder.device import Device
 from _balder.vdevice import VDevice
+from _balder.utils.inner_device_managing_metaclass import InnerDeviceManagingMetaclass
 
 
-class Feature:
+class Feature(metaclass=InnerDeviceManagingMetaclass):
     """
     This is the basic feature class. It represents an abstract class that should not be used directly. It is the base
     class for all feature elements.

_balder/feature_replacement_mapping.py

@@ -1,6 +1,8 @@
-from typing import Union
+from typing import Union, Type
 import dataclasses
+from .device import Device
 from .feature import Feature
+from .controllers import DeviceController
 
 
 class FeatureReplacementMapping:
@@ -37,6 +39,20 @@ class FeatureReplacementMapping:
         """
         return [mapping.attr_name for mapping in self._mappings]
 
+    @property
+    def all_scenario_features(self) -> list[Feature]:
+        """
+        returns all scenario features
+        """
+        return [mapping.scenario_feature for mapping in self._mappings]
+
+    @property
+    def all_setup_features(self) -> list[Feature]:
+        """
+        returns all setup features
+        """
+        return [mapping.setup_feature for mapping in self._mappings]
+
     def add(self, attr_name: str, scenario_feature: Union[Feature, None], setup_feature: Feature):
         """
         adds a new mapping
@@ -67,3 +83,25 @@ class FeatureReplacementMapping:
             if mapping.setup_feature == setup_feature:
                 return mapping.scenario_feature
         raise KeyError(f'cannot find setup feature for {setup_feature}')
+
+    def add_remaining_setup_features_as_autonomous(self, cur_setup_device: Type[Device]):
+        """
+        Adds all features that were not added as autonomous features.
+        """
+        cur_setup_features = DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
+
+        # also add all setup features that are not assigned as autonomous features
+        for cur_setup_feature in cur_setup_features.values():
+            if cur_setup_feature not in self.all_setup_features:
+                # determine free name
+                idx = 0
+                autonomous_name = None
+                while (autonomous_name is None
+                       or autonomous_name in self.attr_names):
+                    autonomous_name = f"_autonomous_feat_{idx}"
+                    idx += 1
+                self.add(
+                    attr_name=autonomous_name,
+                    scenario_feature=None,
+                    setup_feature=cur_setup_feature
+                )

_balder/fixture_manager.py

@@ -19,7 +19,7 @@ from _balder.exceptions import LostInExecutorTreeException, FixtureReferenceErro
     UnclearUniqueClassReference
 
 if TYPE_CHECKING:
-    from _balder.utils import MethodLiteralType
+    from _balder.utils.functions import MethodLiteralType
     from _balder.executor.executor_tree import ExecutorTree
 
 

_balder/fixture_metadata.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from typing import Union, Type, Callable, Generator, TYPE_CHECKING
 import dataclasses
 
-from .utils import MethodLiteralType
+from .utils.typings import MethodLiteralType
 
 if TYPE_CHECKING:
     from _balder.scenario import Scenario

_balder/routing_path.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import List, Union, Dict, Type, Tuple, TYPE_CHECKING
+from typing import List, Union, Dict, Type, Tuple, Iterable, TYPE_CHECKING
 
 import copy
 from _balder.connection import Connection
@@ -57,11 +57,24 @@ class RoutingPath:
 
     # ---------------------------------- STATIC METHODS ----------------------------------------------------------------
 
+    @staticmethod
+    def __get_abs_setup_dev_cnns_for(setup_devices: Iterable[Type[Device]]) -> List[Connection]:
+        """
+        Determines all absolute device connections for a given list of setup devices.
+        """
+        setup_devices_cnns = []
+        for cur_setup_device in setup_devices:
+            for cur_cnn_list in DeviceController.get_for(cur_setup_device).get_all_absolute_connections().values():
+                setup_devices_cnns.extend(cur_cnn_list)
+        # remove duplicates
+        return list(set(setup_devices_cnns))
+
     @staticmethod
     def route_through(
-            scenario_connection: Connection, device_mapping: Dict[Type[Device], Type[Device]],
-            alternative_setup_device_cnns: Union[List[Connection], None] = None) \
-            -> List[RoutingPath]:
+            scenario_connection: Connection,
+            device_mapping: Dict[Type[Device], Type[Device]],
+            alternative_setup_device_cnns: Union[List[Connection], None] = None
+    ) -> List[RoutingPath]:
         """
         This static method tries to route the given ``scenario_connection`` with the device_mapping. It returns a list
         of all matched routings between the mapped devices, where the routing is valid to support the requested
@@ -77,12 +90,7 @@ class RoutingPath:
         """
         setup_devices_cnns = alternative_setup_device_cnns
         if alternative_setup_device_cnns is None:
-            setup_devices_cnns = []
-            for cur_setup_device in device_mapping.values():
-                for cur_cnn_list in DeviceController.get_for(cur_setup_device).get_all_absolute_connections().values():
-                    setup_devices_cnns.extend(cur_cnn_list)
-            # remove duplicates
-            setup_devices_cnns = list(set(setup_devices_cnns))
+            setup_devices_cnns = RoutingPath.__get_abs_setup_dev_cnns_for(device_mapping.values())
 
         from_setup_device = device_mapping[scenario_connection.from_device]
         to_setup_device = device_mapping[scenario_connection.to_device]

_balder/scenario.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
+from _balder.utils.inner_device_managing_metaclass import InnerDeviceManagingMetaclass
 
 
-class Scenario:
+class Scenario(metaclass=InnerDeviceManagingMetaclass):
     """
     This is the basic scenario class. It represents an abstract class that should be the base class for all scenarios.
     """
-    RUN = []
     SKIP = []
     IGNORE = []
 

_balder/setup.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
+from _balder.utils.inner_device_managing_metaclass import InnerDeviceManagingMetaclass
 
 
-class Setup:
+class Setup(metaclass=InnerDeviceManagingMetaclass):
     """
     This is the abstract basic setup class. It has to be the base class for all setups.
     """

_balder/testresult.py

@@ -106,9 +106,10 @@ class BranchBodyResult(_Result):
         """returns the determined result for the inner branch of the related executor"""
         relative_result = ResultState.NOT_RUN
         priority_order = ResultState.priority_order()
-        for cur_child in self._related_executor.all_child_executors:
-            if priority_order.index(cur_child.executor_result) < priority_order.index(relative_result):
-                relative_result = cur_child.executor_result
+        if self._related_executor.all_child_executors:
+            for cur_child in self._related_executor.all_child_executors:
+                if priority_order.index(cur_child.executor_result) < priority_order.index(relative_result):
+                    relative_result = cur_child.executor_result
         self._result = relative_result
         return self._result