baldertest 0.1.0b9__py3-none-any.whl → 0.1.0b11__py3-none-any.whl

_balder/controllers/normal_scenario_setup_controller.py

@@ -7,10 +7,11 @@ from abc import ABC, abstractmethod
 from _balder.setup import Setup
 from _balder.device import Device
 from _balder.scenario import Scenario
+from _balder.connection_metadata import ConnectionMetadata
 from _balder.controllers.controller import Controller
 from _balder.controllers.device_controller import DeviceController
 from _balder.controllers.vdevice_controller import VDeviceController
-from _balder.exceptions import MultiInheritanceError, DeviceOverwritingError
+from _balder.exceptions import MultiInheritanceError, DeviceOverwritingError, MissingFeaturesOfVDeviceError
 
 if TYPE_CHECKING:
     from _balder.connection import Connection
@@ -278,7 +279,7 @@ class NormalScenarioSetupController(Controller, ABC):
                             found_it = True
                             break
                     if not found_it:
-                        raise Exception(
+                        raise MissingFeaturesOfVDeviceError(
                             f"the device `{related_device.__name__}` which is mapped to the VDevice "
                             f"`{active_vdevice.__name__}` doesn't have an implementation for the feature "
                             f"`{cur_vdevice_feature.__class__.__name__}` required by the VDevice class "
@@ -374,11 +375,10 @@ class NormalScenarioSetupController(Controller, ABC):
                         all_devices[all_devices_as_strings.index(cur_parent_cnn.from_device.__name__)]
                     related_to_device = all_devices[all_devices_as_strings.index(cur_parent_cnn.to_device.__name__)]
                     new_cnn = cur_parent_cnn.clone()
-                    new_cnn.set_metadata_for_all_subitems(None)
-                    new_cnn.set_metadata_for_all_subitems(
-                        {"from_device": related_from_device, "to_device": related_to_device,
-                         "from_device_node_name": cur_parent_cnn.from_node_name,
-                         "to_device_node_name": cur_parent_cnn.to_node_name})
+                    new_cnn.set_metadata_for_all_subitems(ConnectionMetadata(
+                        from_device=related_from_device, from_device_node_name=cur_parent_cnn.from_node_name,
+                        to_device=related_to_device, to_device_node_name=cur_parent_cnn.to_node_name)
+                    )
                     all_relevant_cnns.append(new_cnn)
 
                 # throw warning (but only if this scenario/setup has minimum one of the parent classes has inner

_balder/controllers/scenario_controller.py

@@ -1,14 +1,17 @@
 from __future__ import annotations
-from typing import Type, Dict, List, Tuple, Union
+from typing import Type, Dict, List, Tuple, Union, Callable, Iterable, Any
 
 import logging
 import inspect
+from collections import OrderedDict
+from _balder.cnnrelations import OrConnectionRelation
 from _balder.device import Device
 from _balder.scenario import Scenario
 from _balder.connection import Connection
 from _balder.controllers.feature_controller import FeatureController
 from _balder.controllers.device_controller import DeviceController
 from _balder.controllers.normal_scenario_setup_controller import NormalScenarioSetupController
+from _balder.parametrization import FeatureAccessSelector, Parameter
 from _balder.exceptions import UnclearAssignableFeatureConnectionError, ConnectionIntersectionError, \
     MultiInheritanceError
 
@@ -26,6 +29,8 @@ class ScenarioController(NormalScenarioSetupController):
     #: contains all existing scenarios and its corresponding controller object
     _items: Dict[Type[Scenario], ScenarioController] = {}
 
+    _parametrization: Dict[Callable, Dict[str, Union[Iterable[Any], FeatureAccessSelector]]] = {}
+
     def __init__(self, related_cls, _priv_instantiate_key):
 
         # describes if the current controller is for setups or for scenarios (has to be set in child controller)
@@ -72,6 +77,92 @@ class ScenarioController(NormalScenarioSetupController):
 
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
+    def register_parametrization(
+            self,
+            test_method: Callable,
+            field_name: str,
+            values: Iterable[Any] | FeatureAccessSelector
+    ) -> None:
+        """
+        This method registers a custom parametrization for a test method of this Scenario
+        """
+        if test_method not in self.get_all_test_methods():
+            raise ValueError(f'got test method `{test_method.__qualname__}` which is no part of the '
+                             f'scenario `{self.related_cls}`')
+        if test_method not in self._parametrization.keys():
+            self._parametrization[test_method] = {}
+        if field_name in self._parametrization[test_method].keys():
+            raise ValueError(f'field name `{field_name}` for test method `{test_method.__qualname__}` already '
+                             f'registered')
+        self._parametrization[test_method][field_name] = values
+
+    def get_parametrization_for(
+            self,
+            test_method: Callable,
+            static: bool = True,
+            dynamic: bool = True,
+    ) -> OrderedDict[str, Iterable[Any] | FeatureAccessSelector] | None:
+        """
+        This method returns the parametrization for a test method of this Scenario. It returns the parameter
+        configuration for every parameter in an OrderedDict.
+
+        :param test_method: the test method of the Scenario
+        :param static: if False, all static parameters will not be included into the dict.
+        :param dynamic: if False, all dynamic parameters will not be included into the dict.
+        """
+        if test_method not in self._parametrization.keys():
+            return None
+        params = self._parametrization[test_method]
+
+        # get arguments in defined order
+        arguments = [name for name in inspect.getfullargspec(test_method).args if name in params.keys()]
+        ordered_dict = OrderedDict()
+        for cur_arg in arguments:
+            cur_value = params[cur_arg]
+            if isinstance(cur_value, FeatureAccessSelector) and dynamic is False:
+                continue
+            if not isinstance(cur_value, FeatureAccessSelector) and static is False:
+                continue
+            ordered_dict[cur_arg] = params[cur_arg]
+        return ordered_dict
+
+    def check_for_parameter_loop_in_dynamic_parametrization(self, cur_fn: Callable):
+        """
+        This method checks for a parameter loop in all dynamic parametrization for a specific test method. If it detects
+        a loop an AttributeError is thrown
+        """
+        # only dynamic parametrization can have Parameter
+        parametrization = self.get_parametrization_for(cur_fn, static=False, dynamic=True)
+
+        def get_dependent_parameters_of_attribute(attribute: str) -> List[str] | None:
+            cur_feature_access_selector = parametrization.get(attribute)
+            if cur_feature_access_selector is None:
+                return None
+            # relevant are parameters only if they are from :class:`Parameter` and contained in the dynamic
+            # parametrization
+            return [param.name for param in cur_feature_access_selector.parameters.values()
+                    if isinstance(param, Parameter) and param.name in parametrization.keys()]
+
+        def recursive_parameter_loop_check(for_attribute, with_attribute: str):
+            dependent_attr = get_dependent_parameters_of_attribute(with_attribute)
+            if dependent_attr is None:
+                # no problematic dependencies because attribute is no dynamic attribute
+                return
+            if len(dependent_attr) == 0:
+                # no problematic dependencies
+                return
+
+            if for_attribute in dependent_attr:
+                # loop detected
+                raise AttributeError('detect a loop in Parameter() object - can not apply parametrization')
+            # go deeper and resolve all dependent
+            for cur_dependent_attr in dependent_attr:
+                recursive_parameter_loop_check(for_attribute, cur_dependent_attr)
+            return
+
+        for cur_attr in parametrization.keys():
+            recursive_parameter_loop_check(cur_attr, cur_attr)
+
     def get_next_parent_class(self) -> Union[Type[Scenario], None]:
         """
         This method returns the next parent class which is a subclass of the :class:`Scenario` itself.
@@ -125,15 +216,15 @@ class ScenarioController(NormalScenarioSetupController):
 
                 # now check if one or more single of the classbased connection are CONTAINED IN the possible
                 # parallel connection (only if there exists more than one parallel)
-                feature_cnn = Connection.based_on(*FeatureController.get_for(
-                        cur_feature.__class__).get_abs_class_based_for_vdevice()[mapped_vdevice])
+                feature_cnn = FeatureController.get_for(
+                    cur_feature.__class__).get_abs_class_based_for_vdevice()[mapped_vdevice]
 
                 # search node names that is the relevant connection
                 relevant_cnns: List[Connection] = []
                 mapped_device_abs_cnns = DeviceController.get_for(mapped_device).get_all_absolute_connections()
                 for _, all_connections in mapped_device_abs_cnns.items():
                     relevant_cnns += [cur_cnn for cur_cnn in all_connections
-                                      if cur_cnn.has_connection_from_to(cur_from_device, mapped_device)]
+                                      if cur_cnn.has_connection_from_to(cur_from_device, end_device=mapped_device)]
 
                 if len(relevant_cnns) <= 1:
                     # ignore if there are not more than one relevant connection
@@ -248,10 +339,9 @@ class ScenarioController(NormalScenarioSetupController):
                     continue
 
                 # now try to reduce the scenario connections according to the requirements of the feature class
-                cur_feature_class_based_for_vdevice = \
+                cur_feature_cnn = \
                     FeatureController.get_for(
                         cur_feature.__class__).get_abs_class_based_for_vdevice()[mapped_vdevice]
-                cur_feature_cnn = Connection.based_on(*cur_feature_class_based_for_vdevice)
 
                 device_cnn_singles = get_single_cnns_between_device_for_feature(
                     from_device=cur_from_device, to_device=mapped_device, relevant_feature_cnn=cur_feature_cnn)
@@ -305,7 +395,7 @@ class ScenarioController(NormalScenarioSetupController):
                         cur_from_device_controller = DeviceController.get_for(cur_from_device)
                         cur_to_device_controller = DeviceController.get_for(cur_to_device)
 
-                        new_cnn = Connection.based_on(*cur_single_cnns)
+                        new_cnn = Connection.based_on(OrConnectionRelation(*cur_single_cnns))
                         new_cnn.set_metadata_for_all_subitems(cur_single_cnns[0].metadata)
                         if cur_from_device == cur_single_cnns[0].from_device:
                             cur_from_device_controller.add_new_absolute_connection(new_cnn)

_balder/controllers/setup_controller.py

@@ -3,7 +3,6 @@ from typing import Type, Dict, Union, TYPE_CHECKING
 
 import logging
 from _balder.setup import Setup
-from _balder.connection import Connection
 from _balder.exceptions import IllegalVDeviceMappingError, MultiInheritanceError
 from _balder.controllers.feature_controller import FeatureController
 from _balder.controllers.device_controller import DeviceController
@@ -113,12 +112,12 @@ class SetupController(NormalScenarioSetupController):
                     continue
 
                 # there exists a class based requirement for this vDevice
-                class_based_cnn = Connection.based_on(*feature_class_based_for_vdevice[mapped_vdevice])
+                class_based_cnn = feature_class_based_for_vdevice[mapped_vdevice]
                 # search relevant connection
                 cur_device_controller = DeviceController.get_for(cur_device)
                 for _, cur_cnn_list in cur_device_controller.get_all_absolute_connections().items():
                     for cur_cnn in cur_cnn_list:
-                        if not cur_cnn.has_connection_from_to(cur_device, mapped_device):
+                        if not cur_cnn.has_connection_from_to(cur_device, end_device=mapped_device):
                             # this connection can be ignored, because it is no connection between the current device
                             # and the mapped device
                             continue

_balder/decorator_connect.py

@@ -5,10 +5,15 @@ import re
 from _balder.device import Device
 from _balder.connection import Connection
 from _balder.controllers import DeviceController
+from _balder.cnnrelations import AndConnectionRelation, OrConnectionRelation
 
 
-def connect(with_device: Union[Type[Device], str], over_connection: Union[Type[Connection], Connection],
-            self_node_name: str = None, dest_node_name: str = None):
+def connect(
+        with_device: Union[Type[Device], str],
+        over_connection: Union[Connection, Type[Connection], AndConnectionRelation, OrConnectionRelation],
+        self_node_name: str = None,
+        dest_node_name: str = None
+):
     """
     This decorator connects two devices with each other. It can be used for scenarios as well as setup devices.
 
@@ -27,11 +32,6 @@ def connect(with_device: Union[Type[Device], str], over_connection: Union[Type[C
     if not isinstance(with_device, str) and not issubclass(with_device, Device):
         raise ValueError("the value of `with_device` must be a `Device` (or a subclass thereof) or the device name "
                          "as a string")
-    if isinstance(over_connection, tuple):
-        # doesn't make sense, because we can describe what's needed in one scenario with several `@connect` decorations
-        # anyway. We are describing a setup, therefore an AND link makes no sense here either
-        raise TypeError("an AND link (signaled via the tuple) of the connection is not possible here - for further "
-                        "separate connections use the `@connect` decorator again")
     if isinstance(over_connection, type):
         if not issubclass(over_connection, Connection):
             raise TypeError("the type of `over_connection` must be a `Connection` (or a subclass of it)")
@@ -91,11 +91,13 @@ def connect(with_device: Union[Type[Device], str], over_connection: Union[Type[C
                 #  in another `@connect()` decorator (and also remove possible metadata from the new clone)
                 cur_cnn_instance = over_connection.clone()
                 cur_cnn_instance.set_metadata_for_all_subitems(None)
-            elif issubclass(over_connection, Connection):
+            elif isinstance(over_connection, type) and issubclass(over_connection, Connection):
                 # not instantiated -> instantiate it
                 cur_cnn_instance = over_connection()
-            cur_cnn_instance.set_devices(from_device=decorated_cls, to_device=with_device)
-            cur_cnn_instance.update_node_names(from_device_node_name=self_node_name, to_device_node_name=dest_node_name)
+            elif isinstance(over_connection, (AndConnectionRelation, OrConnectionRelation)):
+                over_connection = Connection.based_on(over_connection)
+            cur_cnn_instance.metadata.set_from(from_device=decorated_cls, from_device_node_name=self_node_name)
+            cur_cnn_instance.metadata.set_to(to_device=with_device, to_device_node_name=dest_node_name)
 
             decorated_cls_device_controller.add_new_raw_connection(cur_cnn_instance)
             return decorated_cls

_balder/decorator_fixture.py

@@ -3,7 +3,7 @@ from typing import Literal
 
 import functools
 from _balder.collector import Collector
-from _balder.fixture_manager import FixtureManager
+from _balder.fixture_execution_level import FixtureExecutionLevel
 
 
 def fixture(level: Literal['session', 'setup', 'scenario', 'variation', 'testcase']):
@@ -12,17 +12,14 @@ def fixture(level: Literal['session', 'setup', 'scenario', 'variation', 'testcas
 
     :param level: the execution level the fixture should have
     """
-    allowed_levels = FixtureManager.EXECUTION_LEVEL_ORDER
+    allowed_levels = [level.value for level in FixtureExecutionLevel]
 
     if level not in allowed_levels:
         raise ValueError(f"the value of `level` must be a `str` with one of the values `{'`, `'.join(allowed_levels)}`")
 
     def decorator_fixture(func):
-        # always add the fixture to FixtureManager.raw_fixtures - class determination will be done later by
-        # :meth:`Collector`
-        if level not in Collector.raw_fixtures.keys():
-            Collector.raw_fixtures[level] = []
-        Collector.raw_fixtures[level].append(func)
+        # always register the raw fixture in Collector - class determination will be done later by :meth:`Collector`
+        Collector.register_raw_fixture(func, level)
 
         @functools.wraps(func)
         def wrapper_fixture(*args, **kwargs):

_balder/decorator_for_vdevice.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
-from typing import List, Union, Type, Tuple
+from typing import Union, Type
 
 import inspect
+from _balder.cnnrelations import AndConnectionRelation, OrConnectionRelation
 from _balder.collector import Collector
 from _balder.feature import Feature
-from _balder.device import Device
 from _balder.vdevice import VDevice
 from _balder.connection import Connection
 from _balder.controllers import FeatureController
@@ -12,11 +12,11 @@ from _balder.exceptions import DuplicateForVDeviceError, UnknownVDeviceException
 
 
 def for_vdevice(
-        vdevice: Union[str, Device],
+        vdevice: Union[str, Type[VDevice]],
         with_connections: Union[
-            Type[Connection], Connection, Tuple[Union[Type[Connection], Connection]],
-            List[Union[Type[Connection], Connection, Tuple[Union[Type[Connection], Connection]]]]] = Connection(),
-                ):
+            Type[Connection], Connection, AndConnectionRelation, OrConnectionRelation
+        ] = Connection(),
+):
     """
     With the `@for_vdevice` you can limit the decorated object for a special allowed connection tree for every existing
     vDevice. This decorator can be used to decorate whole :class:`Feature` classes just like single methods of a
@@ -38,29 +38,22 @@ def for_vdevice(
 
     :param with_connections: the assigned connection trees for this class/method (default: a universal connection)
     """
-    idx = 0
-    if not isinstance(with_connections, list):
-        with_connections = [with_connections]
-    for cur_conn in with_connections:
-        if isinstance(cur_conn, type):
-            if not issubclass(cur_conn, Connection):
-                raise ValueError(f"the given element type for the element on position `{idx}` has to be a subclass of "
-                                 f"`{Connection.__name__}` or a element of it")
-        elif isinstance(cur_conn, tuple):
-            tuple_idx = 0
-            for cur_tuple_elem in cur_conn:
-                if not isinstance(cur_tuple_elem, Connection) and not issubclass(cur_tuple_elem, Connection):
-                    raise ValueError(f"the given tuple element `{tuple_idx}` that is given on position `{idx}` "
-                                     f"has to be a subclass of `{Connection.__name__}`")
-                tuple_idx += 1
-        elif not isinstance(cur_conn, Connection):
-            raise ValueError(f"the given type on position `{idx}` has to be a subclass of `{Connection.__name__}` or "
-                             f"a element of it")
-
-        idx += 1
+    if isinstance(with_connections, Connection):
+        # do nothing
+        pass
+    elif isinstance(with_connections, (AndConnectionRelation, OrConnectionRelation)):
+        # use container connection
+        with_connections = Connection.based_on(with_connections)
+    elif isinstance(with_connections, type) and issubclass(with_connections, Connection):
+        # instantiate it
+        with_connections = with_connections()
+    else:
+        raise TypeError(f"the given element ``with_connection`` needs to be from type `AndConnectionRelation`, "
+                        f"`OrConnectionRelation` or `Connection` - `{type(with_connections)}` is not allowed")
+
     # note: if `args` is an empty list - no special sub-connection-tree bindings
 
-    if not isinstance(vdevice, str) and not isinstance(vdevice, VDevice):
+    if not (isinstance(vdevice, str) or (isinstance(vdevice, type) and issubclass(vdevice, VDevice))):
         raise ValueError('the given element for `vdevice` has to be a `str` or has to be a subclass of'
                          '`VDevice`')
 
@@ -74,9 +67,7 @@ def for_vdevice(
             self.func = func
 
             # we detect a decorated non-class object -> save it and check it later in collector
-            if func not in Collector._possible_method_variations.keys():
-                Collector._possible_method_variations[func] = []
-            Collector._possible_method_variations[func].append((vdevice, with_connections))
+            Collector.register_possible_method_variation(func, vdevice, with_connections)
 
         def __new__(cls, *args, **kwargs):  # pylint: disable=unused-argument
             nonlocal vdevice
@@ -107,7 +98,6 @@ def for_vdevice(
 
                     vdevice = relevant_vdevices[0]
                 cls_for_vdevice = fn_feature_controller.get_class_based_for_vdevice()
-                cls_for_vdevice = {} if cls_for_vdevice is None else cls_for_vdevice
                 if vdevice in cls_for_vdevice.keys():
                     raise DuplicateForVDeviceError(
                         f'there already exists a decorator for the vDevice `{vdevice}` in the Feature class '

_balder/decorator_gateway.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from _balder.controllers.device_controller import DeviceController
 from _balder.device import Device
 from _balder.node_gateway import NodeGateway
 
@@ -25,10 +26,9 @@ def gateway(from_node: str, to_node: str, bidirectional: bool = True):
             raise TypeError(
                 f"The decorator `gateway` may only be used for `Device` objects. This is not possible for the applied "
                 f"class `{cls.__name__}`.")
+        decorated_cls_device_controller = DeviceController.get_for(cls)
 
-        if not hasattr(cls, '_gateways'):
-            cls._gateways = []
         new_gateway = NodeGateway(cls, from_node, to_node, bidirectional)
-        cls._gateways.append(new_gateway)
+        decorated_cls_device_controller.add_new_raw_gateway(new_gateway)
         return cls
     return decorator

_balder/decorator_parametrize.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+from typing import Iterable, Any
+
+import inspect
+from _balder.collector import Collector
+
+
+def parametrize(
+        field_name: str,
+        values: Iterable[Any],
+):
+    """
+    Allows to parametrize a test function. This decorator will be used to statically parametrize a test function.
+
+    :param field_name: the field name of the test function
+
+    :param values: an iterable of values, that should be used to parametrize the test function
+    """
+    if not isinstance(field_name, str):
+        raise ValueError('the given field name must be a string')
+
+    def decorator(func):
+        nonlocal field_name
+        nonlocal values
+
+        if not inspect.isfunction(func):
+            raise TypeError('the decorated object needs to be a test method')
+
+        Collector.register_possible_parametrization(func, field_name, values)
+        return func
+    return decorator

_balder/decorator_parametrize_by_feature.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+from typing import Dict, Tuple, Type
+
+import inspect
+from _balder.collector import Collector
+from _balder.device import Device
+from _balder.parametrization import FeatureAccessSelector, Parameter, Value
+
+
+def parametrize_by_feature(
+        field_name: str,
+        feature_accessor: Tuple[Type[Device], str, str],
+        parameter: Dict[str, FeatureAccessSelector | Parameter | Value] = None
+):
+    """
+    Allows to parametrize a test function. This decorator will be used to dynamically parametrize a test function, by
+    the value a setup feature returns before entering the test.
+
+    :param field_name: the field name of the test function
+    :param feature_accessor: a tuple that provides information for accessing the feature
+    :param parameter: the parameter to parametrize the feature method (if necessary)
+    """
+    if not isinstance(field_name, str):
+        raise ValueError('the given field name must be a string')
+    if parameter is None:
+        parameter = {}
+
+    feature_accessor = FeatureAccessSelector(*feature_accessor, parameters=parameter)
+
+    def decorator(func):
+        if not inspect.isfunction(func):
+            raise TypeError('the decorated object needs to be a test method')
+
+        Collector.register_possible_parametrization(func, field_name, feature_accessor)
+        return func
+    return decorator

_balder/exceptions.py

@@ -158,6 +158,12 @@ class IllegalVDeviceMappingError(BalderException):
     """
 
 
+class MissingFeaturesOfVDeviceError(BalderException):
+    """
+    is thrown if the related device does not implement all features specified in its mapped VDevice.
+    """
+
+
 class NotApplicableVariationException(BalderException):
     """
     is thrown internally after the current variation is not applicable

_balder/executor/basic_executable_executor.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING
+
+import sys
+
+import traceback
+from abc import ABC, abstractmethod
+
+from _balder.executor.basic_executor import BasicExecutor
+from _balder.testresult import ResultState, TestcaseResult
+
+if TYPE_CHECKING:
+    from _balder.fixture_execution_level import FixtureExecutionLevel
+    from _balder.fixture_manager import FixtureManager
+
+
+class BasicExecutableExecutor(BasicExecutor, ABC):
+    """
+    The BasicExecutor class is an abstract class that represents the parent class of all executors. Together with other
+    executor classes, an executor forms a tree structure in which individual tests, which later on are executed, are
+    assigned to individual scenarios
+    """
+    fixture_execution_level: FixtureExecutionLevel = None
+
+    def __init__(self):
+        super().__init__()
+
+        # holds the execution time of this branch (with branch fixtures)
+        self.execution_time_sec = None
+
+    # ---------------------------------- STATIC METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- CLASS METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- PROPERTIES --------------------------------------------------------------------
+
+    @property
+    @abstractmethod
+    def fixture_manager(self) -> FixtureManager:
+        """returns the active fixture manager instance"""
+
+    # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
+
+    @abstractmethod
+    def _prepare_execution(self, show_discarded):
+        """
+        This method runs before the branch will be executed and before the fixture construction code of this branch
+        runs.
+        """
+
+    @abstractmethod
+    def _body_execution(self, show_discarded):
+        """
+        This method runs between the fixture construction and teardown code. It should trigger the execution of the
+        child branches.
+        """
+
+    @abstractmethod
+    def _cleanup_execution(self, show_discarded):
+        """
+        This method runs after the branch was executed (also after the fixture teardown code ran)
+        """
+
+    # ---------------------------------- METHODS -----------------------------------------------------------------------
+
+    def set_result_for_whole_branch(self, value: ResultState):
+        """
+        This method sets the executor result for all sub executors.
+
+        :param value: the new value that should be set for this branch
+        """
+        if value not in (ResultState.SKIP, ResultState.COVERED_BY, ResultState.NOT_RUN):
+            raise ValueError("can not set a state that is not NOT_RUN, SKIP or COVERED_BY for a whole branch")
+        for cur_child_executor in self.all_child_executors:
+            if isinstance(cur_child_executor.body_result, TestcaseResult):
+                cur_child_executor.body_result.set_result(result=value, exception=None)
+
+    @abstractmethod
+    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
+        remove these branches, because they have no valid matchings.
+
+        :param consider_discarded: true if this method should consider discarded branches, otherwise False
+        """
+
+    def filter_tree_for_user_filters(self):
+        """
+        This method calls all user defined filters that are to be applied to the executor tree.
+        """
+        for cur_child_executor in self.all_child_executors:
+            cur_child_executor.filter_tree_for_user_filters()
+
+    def execute(self, show_discarded=False):
+        """
+        Executes the whole branch
+        """
+        start_time = time.perf_counter()
+        self._prepare_execution(show_discarded=show_discarded)
+
+        try:
+            try:
+                if self.has_runnable_tests():
+                    self.fixture_manager.enter(self)
+                    self.construct_result.set_result(ResultState.SUCCESS)
+
+                self._body_execution(show_discarded=show_discarded)
+            except Exception as exc:  # pylint: disable=broad-exception-caught
+                # this has to be a construction fixture error
+                traceback.print_exception(*sys.exc_info())
+                self.construct_result.set_result(ResultState.ERROR, exc)
+            finally:
+                if self.has_runnable_tests():
+                    if self.fixture_manager.is_allowed_to_leave(self):
+                        self.fixture_manager.leave(self)
+                        self.teardown_result.set_result(ResultState.SUCCESS)
+        except Exception as exc:  # pylint: disable=broad-exception-caught
+            # this has to be a teardown fixture error
+            traceback.print_exception(*sys.exc_info())
+            self.teardown_result.set_result(ResultState.ERROR, exc)
+
+        self._cleanup_execution(show_discarded=show_discarded)
+
+        self.execution_time_sec = time.perf_counter() - start_time