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

_balder/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.0b9'
+__version__ = version = '0.1.0b10'
 __version_tuple__ = version_tuple = (0, 1, 0)

_balder/balder_session.py

@@ -289,8 +289,10 @@ class BalderSession:
         """
         This method resolves all classes and executes different checks, that can be done before the test session starts.
         """
-        self.solver = Solver(setups=self.all_collected_setups, scenarios=self.all_collected_scenarios,
-                             connections=self.all_collected_connections, raw_fixtures=self.collector.raw_fixtures)
+        self.solver = Solver(setups=self.all_collected_setups,
+                             scenarios=self.all_collected_scenarios,
+                             connections=self.all_collected_connections,
+                             fixture_manager=self.collector.get_fixture_manager())
         self.solver.resolve(plugin_manager=self.plugin_manager)
 
     def create_executor_tree(self):

_balder/collector.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import List, Type, Union, Dict, Callable, Tuple, TYPE_CHECKING
+from typing import List, Type, Union, Dict, Callable, Tuple, Iterable, Any, TYPE_CHECKING
 
 import os
 import sys
@@ -10,13 +10,16 @@ import inspect
 import pathlib
 import functools
 import importlib.util
-from _balder.utils import get_class_that_defines_method
+from _balder.utils import get_class_that_defines_method, inspect_method
 from _balder.setup import Setup
 from _balder.device import Device
 from _balder.feature import Feature
 from _balder.vdevice import VDevice
 from _balder.scenario import Scenario
 from _balder.connection import Connection
+from _balder.parametrization import FeatureAccessSelector, Parameter
+from _balder.fixture_manager import FixtureManager
+from _balder.fixture_execution_level import FixtureExecutionLevel
 from _balder.controllers import ScenarioController, SetupController, DeviceController, VDeviceController, \
     FeatureController, NormalScenarioSetupController
 from _balder.exceptions import DuplicateForVDeviceError, UnknownVDeviceException
@@ -24,6 +27,7 @@ from _balder.utils import get_scenario_inheritance_list_of
 
 if TYPE_CHECKING:
     from _balder.plugin_manager import PluginManager
+    ConnectionType = Union[Type[Connection], Connection, Tuple[Union[Type[Connection], Connection]]]
 
 logger = logging.getLogger(__file__)
 
@@ -34,16 +38,23 @@ class Collector:
     but secures that all relevant data is being collected.
     """
     # metadata object that contains all raw fixtures (classes that were not be resolved yet)
-    raw_fixtures = {}
+    _raw_fixtures = {}
 
     # this static attribute will be managed by the decorator `@for_vdevice(..)`. It holds all functions/methods that
     # were decorated with `@for_vdevice(..)` (without checking their correctness). The collector will check them later
     # with the method `rework_method_variation_decorators()`
     _possible_method_variations: Dict[
         Callable,
-        List[Tuple[Union[Type[VDevice], str],
-                   Union[Type[Connection], Connection, Tuple[Union[Type[Connection], Connection]],
-                         List[Union[Type[Connection], Connection, Tuple[Union[Type[Connection], Connection]]]]]]]] = {}
+        List[Tuple[Union[Type[VDevice], str], Union[ConnectionType, List[ConnectionType]]]]
+    ] = {}
+
+    # this static attribute will be managed by the decorator `@parametrize(..)`. It holds all functions/methods that
+    # were decorated with `@parametrize(..)` (without checking their correctness). The collector will check it later
+    # with the method `rework_static_parametrization_decorators()`
+    _possible_parametrization: Dict[
+        Callable,
+        Dict[str, Union[Iterable[Any], FeatureAccessSelector]]
+    ] = {}
 
     def __init__(self, working_dir: pathlib.Path):
         self.working_dir = pathlib.Path(working_dir)
@@ -58,6 +69,54 @@ class Collector:
 
         self.balderglob_was_loaded = False
 
+    @staticmethod
+    def register_raw_fixture(fixture: Callable, level: str):
+        """
+        allows to register a new fixture - used by decorator `@balder.fixture()`
+
+        :param level: the fixture level
+        :param fixture: the fixture callable itself
+        """
+        if level not in Collector._raw_fixtures.keys():
+            Collector._raw_fixtures[level] = []
+        Collector._raw_fixtures[level].append(fixture)
+
+    @staticmethod
+    def register_possible_method_variation(
+            meth: Callable,
+            vdevice: Union[Type[VDevice], str],
+            with_connections: Union[ConnectionType, List[ConnectionType]]):
+        """
+        allows to register a new method variation - used by decorator `@balder.for_vdevice()`
+
+        :param meth: the method that should be registered
+        :param vdevice: the vdevice the method is for
+        :param with_connections: the connections the method is for
+        """
+        if meth not in Collector._possible_method_variations.keys():
+            Collector._possible_method_variations[meth] = []
+        Collector._possible_method_variations[meth].append((vdevice, with_connections))
+
+    @staticmethod
+    def register_possible_parametrization(
+            meth: Callable,
+            field_name: str,
+            values: Union[Iterable[Any], FeatureAccessSelector]
+    ):
+        """
+        allows to register a possible parametrization - used by decorator `@balder.parametrize()` or
+        `@balder.parametrize_by_feature()`
+
+        :param meth: the method that should be registered
+        :param field_name: the name of the method argument, the parametrized value should be added
+        :param values: an Iterable of all values that should be parametrized or the FeatureAccessSelector object
+        """
+        if meth not in Collector._possible_parametrization.keys():
+            Collector._possible_parametrization[meth] = {}
+        if field_name in Collector._possible_parametrization[meth].keys():
+            raise ValueError(f'field `{field_name}` already registered for method `{meth.__qualname__}`')
+        Collector._possible_parametrization[meth][field_name] = values
+
     @property
     def all_pyfiles(self) -> List[pathlib.Path]:
         """returns a list of all python files that were be found by the collector"""
@@ -96,6 +155,23 @@ class Collector:
             raise AttributeError("please call the `collect()` method before omitting this value")
         return self._all_connections
 
+    def get_fixture_manager(self) -> FixtureManager:
+        """
+        Resolves all fixtures and returns the fixture manager for this session
+        :return: the fixture manager that is valid for this session
+        """
+        resolved_dict = {}
+        for cur_level_as_str, cur_module_fixture_dict in self._raw_fixtures.items():
+            cur_level = FixtureExecutionLevel(cur_level_as_str)
+            resolved_dict[cur_level] = {}
+            for cur_fn in cur_module_fixture_dict:
+                cls, func_type = inspect_method(cur_fn)
+                # mechanism also works for balderglob fixtures (`func_type` is 'function' and `cls` is None)
+                if cls not in resolved_dict[cur_level].keys():
+                    resolved_dict[cur_level][cls] = []
+                resolved_dict[cur_level][cls].append((func_type, cur_fn))
+        return FixtureManager(resolved_dict)
+
     def load_balderglob_py_file(self) -> Union[types.ModuleType, None]:
         """
         This method loads the global balderglob.py file and returns the module or None if the file does not exist.
@@ -475,6 +551,38 @@ class Collector:
             setattr(owner, name, new_callback)
             owner_feature_controller.set_method_based_for_vdevice(owner_for_vdevice)
 
+    @staticmethod
+    def rework_parametrization_decorators():
+        """
+        This method iterates over the static attribute `Collector._possible_static_parametrization` and checks if these
+        decorated functions are valid (if they are test methods and part of a :meth:`Scenario` class).
+        """
+
+        for cur_fn, cur_decorator_data_dict in Collector._possible_parametrization.items():
+            owner = get_class_that_defines_method(cur_fn)
+            if not issubclass(owner, Scenario):
+                raise TypeError(f'the related class of `{cur_fn.__qualname__}` is not a `Scenario` class')
+            owner_scenario_controller = ScenarioController.get_for(owner)
+            if cur_fn not in owner_scenario_controller.get_all_test_methods():
+                raise TypeError(f'the method {cur_fn.__qualname__} is not a test method')
+            args_of_cur_fn = inspect.getfullargspec(cur_fn).args
+
+            for cur_field_name, cur_value_list in cur_decorator_data_dict.items():
+                if isinstance(cur_value_list, FeatureAccessSelector):
+                    # make sure that all parameters exist in test method parametrization
+                    for cur_value_parameter in cur_value_list.parameters.values():
+                        if isinstance(cur_value_parameter, Parameter):
+                            if cur_value_parameter.name not in cur_decorator_data_dict.keys():
+                                raise AttributeError(f'can not find attribute `{cur_value_parameter.name}` that is '
+                                                     f'used in parametrization for attribute `{cur_field_name}` in '
+                                                     f'test method `{cur_fn.__qualname__}`')
+                if cur_field_name not in args_of_cur_fn:
+                    raise ValueError(f'the argument `{cur_field_name}` does not exist in test method '
+                                     f'`{cur_fn.__qualname__}`')
+                owner_scenario_controller.register_parametrization(cur_fn, cur_field_name, cur_value_list)
+
+            owner_scenario_controller.check_for_parameter_loop_in_dynamic_parametrization(cur_fn)
+
     def get_all_scenario_feature_classes(self) -> List[Type[Feature]]:
         """
         This method returns a list with all :class:`Feature` classes that are being instantiated in one or more
@@ -697,7 +805,6 @@ class Collector:
                           if fnmatch.fnmatch(str(cur_abs_path.relative_to(self.working_dir)), cur_pattern)]
         return list(set(remaining))
 
-
     def collect(self, plugin_manager: PluginManager, scenario_filter_patterns: Union[List[str], None],
                 setup_filter_patterns: Union[List[str], None]):
         """
@@ -739,6 +846,7 @@ class Collector:
         self._all_setups = Collector.filter_parent_classes_of(items=self._all_setups)
 
         Collector.rework_method_variation_decorators()
+        Collector.rework_parametrization_decorators()
 
         # do some further stuff after everything was read
         self._set_original_vdevice_in_features()

_balder/console/balder.py

@@ -50,7 +50,7 @@ def _console_balder_debug(cmd_args: Optional[List[str]] = None, working_dir: Uni
             cb_balder_exc(exc)
         traceback.print_exception(*sys.exc_info())
         sys.exit(ExitCode.BALDER_USAGE_ERROR.value)
-    except Exception as exc:
+    except Exception as exc:  # pylint: disable=broad-exception-caught
         # a unexpected error occurs
         if cb_unexpected_exc:
             cb_unexpected_exc(exc)

_balder/controllers/device_controller.py

@@ -122,7 +122,7 @@ class DeviceController(BaseDeviceController, ABC):
             if issubclass(cur_base, Device):
                 if next_base_class is not None:
                     raise MultiInheritanceError(
-                        f"found more than one Devuce parent classes for `{self.related_cls.__name__}` "
+                        f"found more than one Device parent classes for `{self.related_cls.__name__}` "
                         f"- multi inheritance is not allowed for Device classes")
                 next_base_class = cur_base
         if next_base_class == Device:

_balder/controllers/normal_scenario_setup_controller.py

@@ -10,7 +10,7 @@ from _balder.scenario import Scenario
 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 +278,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 "

_balder/controllers/scenario_controller.py

@@ -1,14 +1,16 @@
 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.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 +28,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 +76,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.

_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

@@ -4,7 +4,6 @@ from typing import List, Union, Type, Tuple
 import inspect
 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,7 +11,7 @@ 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(),
@@ -58,9 +57,10 @@ def for_vdevice(
                              f"a element of it")
 
         idx += 1
+
     # 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 +74,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

_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