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

_balder/_version.py

@@ -1,4 +1,16 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '0.1.0b7'
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.0b9'
 __version_tuple__ = version_tuple = (0, 1, 0)

_balder/balder_session.py

@@ -268,11 +268,6 @@ class BalderSession:
 
         self.parsed_args = self.cmd_arg_parser.parse_args(self._alt_cmd_args)
 
-        if self.parsed_args.only_with_scenario is not None:
-            raise NotImplementedError("the parameter `--only-with-scenario` is not supported in this version of balder")
-        if self.parsed_args.only_with_setup is not None:
-            raise NotImplementedError("the parameter `--only-with-setup` is not supported in this version of balder")
-
         self.working_dir = self.parsed_args.working_dir
         self.collect_only = self.parsed_args.collect_only
         self.resolve_only = self.parsed_args.resolve_only
@@ -285,7 +280,10 @@ class BalderSession:
         """
         This method collects all data.
         """
-        self.collector.collect(plugin_manager=self.plugin_manager)
+        self.collector.collect(
+            plugin_manager=self.plugin_manager,
+            scenario_filter_patterns=self.only_with_scenario,
+            setup_filter_patterns=self.only_with_setup)
 
     def solve(self):
         """
@@ -302,7 +300,8 @@ class BalderSession:
         .. note::
             Note that the method creates an :class:`ExecutorTree`, that hasn't to be completely resolved yet.
         """
-        self.executor_tree = self.solver.get_executor_tree(plugin_manager=self.plugin_manager)
+        self.executor_tree = self.solver.get_executor_tree(plugin_manager=self.plugin_manager,
+                                                           add_discarded=self.show_discarded)
         self.plugin_manager.execute_filter_executor_tree(executor_tree=self.executor_tree)
 
     def run(self):

_balder/collector.py

@@ -5,6 +5,7 @@ import os
 import sys
 import types
 import logging
+import fnmatch
 import inspect
 import pathlib
 import functools
@@ -677,27 +678,59 @@ class Collector:
         for cur_setup in self.all_setups:
             SetupController.get_for(cur_setup).validate_feature_possibility()
 
-    def collect(self, plugin_manager: PluginManager):
+    def _filter_paths_after_allowed_paths(self, paths: List[pathlib.Path], filter_patterns: List[str]) \
+            -> List[pathlib.Path]:
+        """
+        This method filters the given list of filepaths for the given filter_patterns. It returns a list with all
+        remaining paths that are mathing the filter statements in `filter_paths`.
+
+        Patterns are the same like for `fnmatch <https://docs.python.org/3/library/fnmatch.html#module-fnmatch>`_.
+
+        :param paths: a list of all filepaths that should be filtered
+        :param filter_patterns: a list of relative filter patterns that should be applied on the files of the classes
+        :return: returns all classes of items that match any of the given patterns.
+        """
+        remaining = []
+
+        for cur_pattern in filter_patterns:
+            remaining += [cur_abs_path for cur_abs_path in paths
+                          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]):
         """
         This method manages the entire collection process.
 
         :param plugin_manager: contains the reference to the used plugin manager
+        :param scenario_filter_patterns: a list with filter patterns for scenarios
+        :param setup_filter_patterns: a list with filter patterns for setups
         """
         # load all py files
         self.load_balderglob_py_file()
         self._all_py_files = self.get_all_py_files()
         self._all_py_files = plugin_manager.execute_modify_collected_pyfiles(self._all_py_files)
 
+        if scenario_filter_patterns:
+            all_scenario_filepaths = self._filter_paths_after_allowed_paths(
+                paths=self._all_py_files, filter_patterns=scenario_filter_patterns)
+        else:
+            all_scenario_filepaths = self._all_py_files
+        if setup_filter_patterns:
+            all_setup_filepaths = self._filter_paths_after_allowed_paths(
+                paths=self._all_py_files, filter_patterns=setup_filter_patterns)
+        else:
+            all_setup_filepaths = self._all_py_files
+
         # collect all `Connection` classes (has to be first, because scenarios/setups can use them)
         self.load_all_connection_classes(py_file_paths=self._all_py_files)
         self._all_connections = self.get_all_connection_classes()
 
         # collect all `Scenario` classes
-        self._all_scenarios = self.get_all_scenario_classes(
-            py_file_paths=self._all_py_files, filter_abstracts=True)
+        self._all_scenarios = self.get_all_scenario_classes(py_file_paths=all_scenario_filepaths, filter_abstracts=True)
         # collect all `Setup` classes
-        self._all_setups = self.get_all_setup_classes(
-            py_file_paths=self._all_py_files, filter_abstracts=True)
+        self._all_setups = self.get_all_setup_classes(py_file_paths=all_setup_filepaths, filter_abstracts=True)
 
         self._all_scenarios, self._all_setups = plugin_manager.execute_collected_classes(
             scenarios=self._all_scenarios, setups=self._all_setups)

_balder/connection.py

@@ -88,6 +88,17 @@ class Connection:
             all_hashes += hash(cur_child)
         return hash(all_hashes)
 
+    def clone_without_based_on_elements(self) -> Connection:
+        """
+        This method returns a copied version of this element, while all `_based_on_connections` are removed (the copied
+        element has an empty list here).
+
+        :return: a python copied object of this item
+        """
+        self_copy = copy.copy(self)
+        self_copy._based_on_connections = []  # pylint: disable=protected-access
+        return self_copy
+
     def clone(self) -> Connection:
         """
         This method returns an exact clone of this connection. For this clone every inner connection object will be
@@ -95,18 +106,15 @@ class Connection:
         same for this object and the clone). The method will make a normal copy for every connection object in the
         `_based_on_elements` list.
         """
-        self_copy = copy.copy(self)
-        self_copy._based_on_connections = []
+        self_copy = self.clone_without_based_on_elements()
 
         for cur_based_on in self._based_on_connections:
             if isinstance(cur_based_on, tuple):
-                cloned_tuple = ()
-                for cur_tuple_element in cur_based_on:
-                    cloned_tuple = cloned_tuple + (cur_tuple_element.clone(), )
-                self_copy._based_on_connections.append(cloned_tuple)
+                cloned_tuple = tuple([cur_tuple_element.clone() for cur_tuple_element in cur_based_on])
+                self_copy.append_to_based_on(cloned_tuple)
             elif isinstance(cur_based_on, Connection):
                 cloned_cur_based_on = cur_based_on.clone()
-                self_copy._based_on_connections.append(cloned_cur_based_on)
+                self_copy.append_to_based_on(cloned_cur_based_on)
             else:
                 raise TypeError('based on element is not from valid type')
         return self_copy
@@ -132,22 +140,21 @@ class Connection:
             for cur_tuple in Connection.__cut_tuple_from_only_parent_to_child(elem.based_on_elements[0]):
                 # for this we do not have to use `clone`, because we copy the base object with `copy.copy` and
                 # completely replace the `_based_on_connections` by our own
-                copied_conn = copy.copy(elem)
-                copied_conn._based_on_connections = [cur_tuple]
+                copied_conn = elem.clone_without_based_on_elements()
+                copied_conn.append_to_based_on(cur_tuple)
                 all_pieces.append(copied_conn)
             return all_pieces
         # if this element is the last element with a parent -> copy it and remove the parent, return it
         if len(elem.based_on_elements[0].based_on_elements) == 0:
-            new_elem = copy.copy(elem)
-            new_elem._based_on_connections = []
+            new_elem = elem.clone_without_based_on_elements()
             all_pieces.append(new_elem)
             return all_pieces
         # otherwise, the current item has grandparents, so call the method recursively for parents and add a copy of
         # this object as child
         all_possible_parents = Connection.__cut_conn_from_only_parent_to_child(elem.based_on_elements[0])
         for cur_parent in all_possible_parents:
-            copied_conn = copy.copy(elem)
-            copied_conn._based_on_connections = [cur_parent]
+            copied_conn = elem.clone_without_based_on_elements()
+            copied_conn.append_to_based_on(cur_parent)
             all_pieces.append(copied_conn)
         return all_pieces
 
@@ -165,15 +172,12 @@ class Connection:
             Note that this method also returns every possible ordering
         """
 
-        tuple_with_all_possibilities = ()
-        for cur_tuple_item in elem:
-            tuple_with_all_possibilities += (Connection.__cut_conn_from_only_parent_to_child(cur_tuple_item), )
+        tuple_with_all_possibilities = (
+            tuple([Connection.__cut_conn_from_only_parent_to_child(cur_tuple_item) for cur_tuple_item in elem]))
 
         cloned_tuple_list = []
         for cur_tuple in list(itertools.product(*tuple_with_all_possibilities)):
-            cloned_tuple: Tuple[Connection] = ()
-            for cur_tuple_item in cur_tuple:
-                cloned_tuple += (cur_tuple_item.clone(), )
+            cloned_tuple = tuple([cur_tuple_item.clone() for cur_tuple_item in cur_tuple])
             cloned_tuple_list.append(cloned_tuple)
         return cloned_tuple_list
 
@@ -215,11 +219,9 @@ class Connection:
                 while len(cur_sub_other_single) > 0:
                     if isinstance(cur_sub_other_single[0], tuple):
                         # found a tuple -> check if length does match
-                        if len(cur_sub_other_single[0]) >= len(cur_tuple_single):
-                            # length does match
-                            if tuple_is_contained_in_other(
-                                    cur_tuple_single, contained_in_tuple=cur_sub_other_single[0]):
-                                return True
+                        if len(cur_sub_other_single[0]) >= len(cur_tuple_single) and tuple_is_contained_in_other(
+                                cur_tuple_single, contained_in_tuple=cur_sub_other_single[0]):
+                            return True
                         # otherwise, this complete element is not possible - skip this single!
                         break
                     cur_sub_other_single = cur_sub_other_single[0].based_on_elements
@@ -371,6 +373,75 @@ class Connection:
         this_instance.append_to_based_on(*new_items)
         return this_instance
 
+    @classmethod
+    def check_equal_connections_are_in(
+            cls, cnns_from: List[Connection], are_in_cnns_from: List[Connection], ignore_metadata: bool=False) -> bool:
+        """
+        This method validates that the elements from the first list are contained (are equal) with one of the elements
+        in the second list.
+
+        .. note::
+            This method only checks that every single connections from the first element is contained in the second too.
+            It does not check the other direction. If you want to validate this, you need to call this method with both
+            possibilities.
+
+        :param cnns_from: the first list of connections
+        :param are_in_cnns_from: the second list of connection
+        :param ignore_metadata: True, if the metadata of the single connections should be ignored
+        :return: True in case that every connection of the first list is equal with one in the second list, otherwise
+                 False
+        """
+        for cur_cnn in cnns_from:
+            found_equal = False
+            for cur_other_cnn in are_in_cnns_from:
+                if cur_cnn.equal_with(cur_other_cnn, ignore_metadata=ignore_metadata):
+                    found_equal = True
+                    break
+            if not found_equal:
+                return False
+        return True
+
+    @classmethod
+    def check_equal_connection_tuples_are_in(
+            cls, tuples_from: List[Tuple[Connection]], are_in_tuples_from: List[Tuple[Connection]],
+            ignore_metadata: bool=False) -> bool:
+        """
+        This method validates that the connection tuples from the first list are contained (are equal) within the tuple
+        elements of the second list.
+
+        .. note::
+            This method only checks that every single tuple from the first element is contained in the second list.
+            It does not check the other direction. If you want to validate this, you need to call this method with both
+            possibilities.
+
+        :param tuples_from: the first list of connection-tuples
+        :param are_in_tuples_from: the second list of connection-tuples
+        :param ignore_metadata: True, if the metadata of the single connections should be ignored
+        :return: True in case that every tuple connections of the first list is equal with one tuple in the second,
+                 otherwise False
+        """
+        for cur_search_tuple in tuples_from:
+            found_match_for_cur_search_tuple = False
+            # go through each unmatched other tuple
+            for cur_other_tuple in are_in_tuples_from:
+                cur_search_tuple_is_completely_in_other_tuple = True
+                for cur_search_tuple_elem in cur_search_tuple:
+                    fount_it = False
+                    for cur_other_tuple_elem in cur_other_tuple:
+                        if cur_search_tuple_elem.equal_with(cur_other_tuple_elem, ignore_metadata=ignore_metadata):
+                            fount_it = True
+                            break
+                    if not fount_it:
+                        cur_search_tuple_is_completely_in_other_tuple = False
+                        break
+                if cur_search_tuple_is_completely_in_other_tuple:
+                    # here we have no match
+                    found_match_for_cur_search_tuple = True
+                    break
+            if not found_match_for_cur_search_tuple:
+                return False
+        return True
+
     # ---------------------------------- PROPERTIES --------------------------------------------------------------------
 
     @property
@@ -484,7 +555,7 @@ class Connection:
 
         return False
 
-    def _get_intersection_with_other_single(self, other_conn: Union[Connection, Tuple[Connection]]) \
+    def get_intersection_with_other_single(self, other_conn: Union[Connection, Tuple[Connection]]) \
             -> List[Connection, Tuple[Connection]]:
         """
         A helper method that returns an intersection between the two connections (self and the given one).
@@ -519,27 +590,23 @@ class Connection:
 
         intersection = []
 
+        def determine_for(pieces: List[Union[Connection, Tuple[Connection]]], in_other_cnn: Connection):
+            for cur_piece in pieces:
+                if isinstance(cur_piece, Connection):
+                    if cur_piece.contained_in(in_other_cnn, ignore_metadata=True):
+                        intersection.append(cur_piece)
+                else:
+                    # isinstance of tuple
+                    if Connection.check_if_tuple_contained_in_connection(cur_piece, in_other_cnn):
+                        intersection.append(cur_piece)
+
         #: check if some sub elements of self connection are contained in `other_conn`
         self_pieces = self.cut_into_all_possible_subtrees()
-        for cur_piece in self_pieces:
-            if isinstance(cur_piece, Connection):
-                if cur_piece.contained_in(other_conn, ignore_metadata=True):
-                    intersection.append(cur_piece)
-            else:
-                # isinstance of tuple
-                if Connection.check_if_tuple_contained_in_connection(cur_piece, other_conn):
-                    intersection.append(cur_piece)
+        determine_for(pieces=self_pieces, in_other_cnn=other_conn)
 
         #: check if some sub elements of `other_conn` are contained in self connection
         other_pieces = other_conn.cut_into_all_possible_subtrees()
-        for cur_piece in other_pieces:
-            if isinstance(cur_piece, Connection):
-                if cur_piece.contained_in(self, ignore_metadata=True):
-                    intersection.append(cur_piece)
-            else:
-                # isinstance of tuple
-                if Connection.check_if_tuple_contained_in_connection(cur_piece, self):
-                    intersection.append(cur_piece)
+        determine_for(pieces=other_pieces, in_other_cnn=self)
 
         #: filter all duplicated (and contained in each other) connections
         intersection_without_duplicates = []
@@ -779,19 +846,19 @@ class Connection:
             method returns this child connection directly without any :class:`Connection` container otherwise the
             :class:`Connection` container class with all resolved child classes will be returned.
         """
-        copied_base = copy.copy(self)
-        if not copied_base.is_resolved():
-            copied_base._based_on_connections = []
+        if self.is_resolved():
+            copied_base = self.clone()
+        else:
+            copied_base = self.clone_without_based_on_elements()
+
             if self.__class__ == Connection:
                 # the base object is a container Connection - iterate over the items and determine the values for them
                 for cur_item in self.based_on_elements.copy():
                     if isinstance(cur_item, tuple):
-                        new_tuple = ()
-                        for cur_tuple_item in cur_item:
-                            new_tuple += (cur_tuple_item.get_resolved(), )
-                        copied_base._based_on_connections.append(new_tuple)
+                        new_tuple = tuple([cur_tuple_item.get_resolved() for cur_tuple_item in cur_item])
+                        copied_base.append_to_based_on(new_tuple)
                     else:
-                        copied_base._based_on_connections.append(cur_item.get_resolved())
+                        copied_base.append_to_based_on(cur_item.get_resolved())
             else:
                 for next_higher_parent in self.based_on_elements:
                     if isinstance(next_higher_parent, tuple):
@@ -811,21 +878,20 @@ class Connection:
                         # resolve the opportunities and create multiple possible tuples where all elements are direct
                         # parents
                         for cur_possibility in itertools.product(*direct_ancestors_tuple):
-                            new_child_tuple = ()
-                            for cur_tuple_element in cur_possibility:
-                                new_child_tuple += (cur_tuple_element.get_resolved(), )
-                            copied_base._based_on_connections.append(new_child_tuple)
+                            new_child_tuple = (
+                                tuple([cur_tuple_element.get_resolved() for cur_tuple_element in cur_possibility]))
+                            copied_base.append_to_based_on(new_child_tuple)
                     else:
                         if next_higher_parent.__class__ in self.__class__.get_parents():
                             # is already a direct parent
-                            copied_base._based_on_connections.append(next_higher_parent.get_resolved())
+                            copied_base.append_to_based_on(next_higher_parent.get_resolved())
                         else:
                             # only add the first level of direct parents - deeper will be added by recursively call of
                             # `get_resolved`
                             for cur_self_direct_parent in self.__class__.get_parents():
                                 if next_higher_parent.__class__.is_parent_of(cur_self_direct_parent):
                                     new_child = cur_self_direct_parent.based_on(next_higher_parent)
-                                    copied_base._based_on_connections.append(new_child.get_resolved())
+                                    copied_base.append_to_based_on(new_child.get_resolved())
         # if it is a connection container, where only one element exists that is no tuple -> return this directly
         # instead of the container
         if copied_base.__class__ == Connection and len(copied_base.based_on_elements) == 1 and not \
@@ -865,8 +931,8 @@ class Connection:
                     return [resolved_obj]
                 for cur_child in resolved_obj.based_on_elements:
                     for cur_single_child in cur_child.get_singles():
-                        copied_base = copy.copy(resolved_obj)
-                        copied_base._based_on_connections = [cur_single_child]
+                        copied_base = resolved_obj.clone_without_based_on_elements()
+                        copied_base.append_to_based_on(cur_single_child)
                         all_singles.append(copied_base)
         # convert all tuple objects in a connection object and set metadata of self object
         cleaned_singles = []
@@ -979,40 +1045,6 @@ class Connection:
         resolved_self = self.get_resolved()
         resolved_other = other_conn.get_resolved()
 
-        def check_elems_if(elems_from, are_in_elems_from):
-            for cur_elem in elems_from:
-                found_equal = False
-                for cur_other_elem in are_in_elems_from:
-                    if cur_elem.equal_with(cur_other_elem, ignore_metadata=ignore_metadata):
-                        found_equal = True
-                        break
-                if not found_equal:
-                    return False
-            return True
-
-        def check_tuples_if(tuples_from, are_in_tuples_from):
-            for cur_search_tuple in tuples_from:
-                found_match_for_cur_search_tuple = False
-                # go through each unmatched other tuple
-                for cur_other_tuple in are_in_tuples_from:
-                    cur_search_tuple_is_completely_in_other_tuple = True
-                    for cur_search_tuple_elem in cur_search_tuple:
-                        fount_it = False
-                        for cur_other_tuple_elem in cur_other_tuple:
-                            if cur_search_tuple_elem.equal_with(cur_other_tuple_elem, ignore_metadata=ignore_metadata):
-                                fount_it = True
-                                break
-                        if not fount_it:
-                            cur_search_tuple_is_completely_in_other_tuple = False
-                            break
-                    if cur_search_tuple_is_completely_in_other_tuple:
-                        # here we have no match
-                        found_match_for_cur_search_tuple = True
-                        break
-                if not found_match_for_cur_search_tuple:
-                    return False
-            return True
-
         self_based_on_elems = [
             cur_elem for cur_elem in resolved_self.based_on_elements if isinstance(cur_elem, Connection)]
         self_based_on_tuples = [
@@ -1023,13 +1055,20 @@ class Connection:
             cur_elem for cur_elem in resolved_other.based_on_elements if isinstance(cur_elem, tuple)]
 
         # check single connection elements (if they match all in both directions)
-        if not check_elems_if(elems_from=self_based_on_elems, are_in_elems_from=other_based_on_elems) or \
-                not check_elems_if(elems_from=other_based_on_elems, are_in_elems_from=self_based_on_elems):
+        if (not self.__class__.check_equal_connections_are_in(
+                cnns_from=self_based_on_elems, are_in_cnns_from=other_based_on_elems, ignore_metadata=ignore_metadata)
+                or not self.__class__.check_equal_connections_are_in(
+                    cnns_from=other_based_on_elems, are_in_cnns_from=self_based_on_elems,
+                    ignore_metadata=ignore_metadata)):
             return False
 
         # check tuple connection elements (if they match all in both directions)
-        if not check_tuples_if(tuples_from=self_based_on_tuples, are_in_tuples_from=other_based_on_tuples) or \
-                not check_tuples_if(tuples_from=other_based_on_tuples, are_in_tuples_from=self_based_on_tuples):
+        if (not self.__class__.check_equal_connection_tuples_are_in(
+                tuples_from=self_based_on_tuples, are_in_tuples_from=other_based_on_tuples,
+                ignore_metadata=ignore_metadata)
+                or not self.__class__.check_equal_connection_tuples_are_in(
+                    tuples_from=other_based_on_tuples, are_in_tuples_from=self_based_on_tuples,
+                    ignore_metadata=ignore_metadata)):
             return False
 
         return True
@@ -1208,7 +1247,7 @@ class Connection:
         # determine intersections between all of these single components
         for cur_self_conn in self_conn_singles:
             for cur_other_conn in other_conn_singles:
-                for cur_intersection in cur_self_conn._get_intersection_with_other_single(cur_other_conn):
+                for cur_intersection in cur_self_conn.get_intersection_with_other_single(cur_other_conn):
                     if isinstance(cur_intersection, tuple):
                         cur_intersection = Connection.based_on(cur_intersection)
                     if cur_intersection not in intersections:
@@ -1236,7 +1275,8 @@ class Connection:
 
         return intersection_filtered[0].clone()
 
-    def append_to_based_on(self, *args: Union[Tuple[Union[Type[Connection], Connection]]]) -> None:
+    def append_to_based_on(
+            self, *args: Union[Connection, Type[Connection], Tuple[Union[Type[Connection], Connection]]]) -> None:
         """
         with this method you can extend the internal based_on list with the transferred elements. Any number of
         :meth:`Connection` objects or tuples with :meth:`Connection` objects can be given to this method

_balder/controllers/feature_controller.py

@@ -129,6 +129,39 @@ class FeatureController(Controller):
             return [Connection()]
         return intersection
 
+    def _determine_all_theoretically_unordered_method_variations(
+            self, of_method_name: str, for_vdevice: Type[VDevice],
+            with_connection: Union[Connection, Tuple[Connection]]) -> Dict[Callable, Connection]:
+        """
+        This method returns all theoretically matching method variations. It returns more than one, if there are
+        multiple method variation for the given VDevice in this feature, where the given connection is part of the
+        connection described by the method variation.
+
+        :param of_method_name: the name of the method that should be returned
+        :param for_vdevice: the VDevice that is mapped
+        :param with_connection: the connection that is used between the device that uses the related feature and the
+                                VDevice
+        :return: a dictionary that holds all available method variation that matches here
+        """
+        all_possible_method_variations = {}
+        for cur_impl_method, cur_method_impl_dict in self.get_method_based_for_vdevice()[of_method_name].items():
+            if for_vdevice in cur_method_impl_dict.keys():
+                cur_impl_method_cnns = []
+                for cur_cnn in cur_method_impl_dict[for_vdevice]:
+                    cur_impl_method_cnns += cur_cnn.get_singles()
+                for cur_single_impl_method_cnn in cur_impl_method_cnns:
+                    if cur_single_impl_method_cnn.contained_in(with_connection, ignore_metadata=True):
+                        # this variation is possible
+                        # ADD IT if it is not available yet
+                        if cur_impl_method not in all_possible_method_variations.keys():
+                            all_possible_method_variations[cur_impl_method] = cur_single_impl_method_cnn
+                        # COMBINE IT if it is already available
+                        else:
+                            all_possible_method_variations[cur_impl_method] = Connection.based_on(
+                                all_possible_method_variations[cur_impl_method], cur_single_impl_method_cnn)
+        return all_possible_method_variations
+
+
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
     def get_class_based_for_vdevice(self) -> Union[Dict[Type[VDevice], List[Connection]], None]:
@@ -321,24 +354,10 @@ class FeatureController(Controller):
             raise ValueError(f"can not find the method `{of_method_name}` in method variation data dictionary")
 
         # first determine all possible method-variations
-        all_possible_method_variations = {}
-        for cur_impl_method, cur_method_impl_dict in self.get_method_based_for_vdevice()[of_method_name].items():
-            if for_vdevice in cur_method_impl_dict.keys():
-                cur_impl_method_cnns = []
-                for cur_cnn in cur_method_impl_dict[for_vdevice]:
-                    cur_impl_method_cnns += cur_cnn.get_singles()
-                for cur_single_impl_method_cnn in cur_impl_method_cnns:
-                    if cur_single_impl_method_cnn.contained_in(with_connection, ignore_metadata=True):
-                        # this variation is possible
-                        # ADD IT if it is not available yet
-                        if cur_impl_method not in all_possible_method_variations.keys():
-                            all_possible_method_variations[cur_impl_method] = cur_single_impl_method_cnn
-                        # COMBINE IT if it is already available
-                        else:
-                            all_possible_method_variations[cur_impl_method] = Connection.based_on(
-                                all_possible_method_variations[cur_impl_method], cur_single_impl_method_cnn)
+        all_possible_method_variations = self._determine_all_theoretically_unordered_method_variations(
+            of_method_name=of_method_name, for_vdevice=for_vdevice, with_connection=with_connection)
 
-        # if there are more than one possible method variation, try to sort them hierarchical
+        # there are no method variations in this feature directly -> check parent classes
         if len(all_possible_method_variations) == 0:
             # try to execute this method in parent classes
             for cur_base in self.related_cls.__bases__:
@@ -355,9 +374,11 @@ class FeatureController(Controller):
                     f"and usable connection `{with_connection.get_tree_str()}´")
             return None
 
+        # we only have one -> selection is clear
         if len(all_possible_method_variations) == 1:
             return list(all_possible_method_variations.keys())[0]
 
+        # if there are more than one possible method variation, try to sort them hierarchical
         # we have to determine the outer one
         length_before = None
         while length_before is None or length_before != len(all_possible_method_variations):

_balder/controllers/normal_scenario_setup_controller.py

@@ -188,7 +188,7 @@ class NormalScenarioSetupController(Controller, ABC):
 
         devices = self.get_all_inner_device_classes()
         abs_parent_devices = parent_scenario_or_setup_controller.get_all_abs_inner_device_classes()
-        abs_parent_devices_as_names = [cur_parent.__name__ for cur_parent in abs_parent_devices]
+        abs_parent_devices_by_name = {cur_parent.__name__: cur_parent for cur_parent in abs_parent_devices}
 
         if len(devices) == 0:
             # ignore it because cur item has no own device definitions
@@ -197,10 +197,7 @@ class NormalScenarioSetupController(Controller, ABC):
         # check that a device is newly defined or has the same name as the parent device
         for cur_item_device in devices:
             # check if name exists in parent
-            relevant_parent_according_naming = None
-            if cur_item_device.__name__ in abs_parent_devices_as_names:
-                relevant_parent_according_naming = \
-                    abs_parent_devices[abs_parent_devices_as_names.index(cur_item_device.__name__)]
+            relevant_parent_according_naming = abs_parent_devices_by_name.get(cur_item_device.__name__, None)
 
             # check if device is inherited from a parent
             relevant_parent_device_according_inheritance = None
@@ -236,11 +233,7 @@ class NormalScenarioSetupController(Controller, ABC):
 
         # secure that all parent devices are implemented here too
         for cur_parent in abs_parent_devices:
-            found_parent = False
-            for cur_item_device in devices:
-                if issubclass(cur_item_device, cur_parent):
-                    found_parent = True
-                    break
+            found_parent = len([dev for dev in devices if issubclass(dev, cur_parent)]) > 0
             if not found_parent:
                 raise DeviceOverwritingError(
                     f"found a device `{cur_parent.__qualname__}` which is part of a parent class, but it is "

_balder/executor/basic_executor.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 import time
-from typing import List, Dict, Union, Type, TYPE_CHECKING
+from typing import List, Union, Type, TYPE_CHECKING
 
 import sys
 import types
 import traceback
 from abc import ABC, abstractmethod
-from _balder.testresult import FixturePartResult, ResultState
+from _balder.testresult import FixturePartResult, ResultState, ResultSummary
 from _balder.previous_executor_mark import PreviousExecutorMark
 from _balder.testresult import TestcaseResult
 
@@ -158,8 +158,7 @@ class BasicExecutor(ABC):
                 if cur_child.has_runnable_tests(consider_discarded_too):
                     return True
             return False
-        else:
-            return True
+        return True
 
     def get_all_base_instances_of_this_branch(
             self, with_type: Union[Type[Setup], Type[Scenario], Type[types.FunctionType]],
@@ -193,10 +192,12 @@ class BasicExecutor(ABC):
         return list(set(result))
 
     @abstractmethod
-    def cleanup_empty_executor_branches(self):
+    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):
@@ -206,31 +207,19 @@ class BasicExecutor(ABC):
         for cur_child_executor in self.all_child_executors:
             cur_child_executor.filter_tree_for_user_filters()
 
-    def testsummary(self) -> Dict[ResultState, int]:
+    def testsummary(self) -> ResultSummary:
         """
         returns a dictionary with all possible :class:`ResultState` as keys and the number of times they have occurred
         in this branch as values
         """
 
-        summary = {
-            ResultState.NOT_RUN: 0,
-            ResultState.FAILURE: 0,
-            ResultState.ERROR: 0,
-            ResultState.SUCCESS: 0,
-            ResultState.SKIP: 0,
-            ResultState.COVERED_BY: 0
-        }
+        summary = ResultSummary()
 
         if isinstance(self.body_result, TestcaseResult):
-            summary[self.executor_result] = 1
+            setattr(summary, self.executor_result.value, 1)
         else:
             for cur_child_exec in self.all_child_executors:
-                cur_child_dict = cur_child_exec.testsummary()
-                for cur_key in cur_child_dict.keys():
-                    if cur_key in summary:
-                        summary[cur_key] += cur_child_dict[cur_key]
-                    else:
-                        summary[cur_key] = cur_child_dict[cur_key]
+                summary += cur_child_exec.testsummary()
         return summary
 
     def execute(self, show_discarded=False):

_balder/executor/executor_tree.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 from typing import Union, List, Type, TYPE_CHECKING
 
+from dataclasses import fields
 from _balder.executor.setup_executor import SetupExecutor
 from _balder.executor.basic_executor import BasicExecutor
 from _balder.fixture_manager import FixtureManager
-from _balder.testresult import ResultState, BranchBodyResult
+from _balder.testresult import ResultState, BranchBodyResult, ResultSummary
 from _balder.previous_executor_mark import PreviousExecutorMark
 
 if TYPE_CHECKING:
@@ -55,7 +56,8 @@ class ExecutorTree(BasicExecutor):
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
 
     def _prepare_execution(self, show_discarded):
-        pass
+        if not show_discarded:
+            self.update_inner_feature_reference_in_all_setups()
 
     def _body_execution(self, show_discarded):
         for cur_setup_executor in self.get_setup_executors():
@@ -129,16 +131,26 @@ class ExecutorTree(BasicExecutor):
         # can not find some
         return None
 
-    def cleanup_empty_executor_branches(self):
+    def cleanup_empty_executor_branches(self, consider_discarded=False):
         to_remove_executor = []
         for cur_setup_executor in self.get_setup_executors():
-            cur_setup_executor.cleanup_empty_executor_branches()
+            cur_setup_executor.cleanup_empty_executor_branches(consider_discarded=consider_discarded)
             if len(cur_setup_executor.get_scenario_executors()) == 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:
             self._setup_executors.remove(cur_setup_executor)
 
+    def update_inner_feature_reference_in_all_setups(self):
+        """
+        This method iterates over all setups and triggers the method that updates the inner feature references.
+
+        This needs to be done on ExecutorTree level, because this reference should also be accessible within session
+        fixtures (in case they have setup scope).
+        """
+        for cur_setup_executor in self.get_setup_executors():
+            cur_setup_executor.update_inner_referenced_feature_instances()
+
     def execute(self, show_discarded=False) -> None:
         """
         This method executes this branch of the tree
@@ -163,12 +175,12 @@ class ExecutorTree(BasicExecutor):
         print_line(end_text)
         summary = self.testsummary()
         is_first = True
-        for cur_key, cur_val in summary.items():
+        for cur_field in fields(ResultSummary):
             if is_first:
                 is_first = False
             else:
                 print(" | ", end="")
-            print(f"TOTAL {cur_key.value}: {cur_val}", end="")
+            print(f"TOTAL {cur_field.name}: {getattr(summary, cur_field.name)}", end="")
         print("")
 
     def print_tree(self, show_discarded=False) -> None:
@@ -192,7 +204,8 @@ class ExecutorTree(BasicExecutor):
                     for cur_key, cur_val in mapping_printings.items():
                         print(("{} {:<" + str(max_len) + "} = {}").format(start_char, cur_key, cur_val))
                     for cur_testcase_excutor in cur_variation_executor.get_testcase_executors():
-                        print(f"{start_char}    -> Testcase<{cur_testcase_excutor.base_testcase_callable.__qualname__}>")
+                        print(f"{start_char}    -> Testcase<"
+                              f"{cur_testcase_excutor.base_testcase_callable.__qualname__}>")
                     if cur_variation_executor.prev_mark == PreviousExecutorMark.DISCARDED:
                         print(f"{start_char}")
                         print(f"{start_char}    DISCARDED BECAUSE "

_balder/executor/scenario_executor.py

@@ -6,6 +6,7 @@ from _balder.utils import get_class_that_defines_method
 from _balder.executor.basic_executor import BasicExecutor
 from _balder.executor.variation_executor import VariationExecutor
 from _balder.previous_executor_mark import PreviousExecutorMark
+from _balder.controllers.scenario_controller import ScenarioController
 
 if TYPE_CHECKING:
     from _balder.scenario import Scenario
@@ -64,6 +65,10 @@ class ScenarioExecutor(BasicExecutor):
         """returns the :class:`Scenario` class that belongs to this executor"""
         return self._base_scenario_class
 
+    @property
+    def base_scenario_controller(self) -> ScenarioController:
+        return ScenarioController.get_for(self.base_scenario_class.__class__)
+
     @property
     def fixture_manager(self) -> FixtureManager:
         """returns the current active fixture manager that belongs to this scenario executor"""
@@ -116,12 +121,12 @@ class ScenarioExecutor(BasicExecutor):
                     if cur_executor.prev_mark != PreviousExecutorMark.DISCARDED]
         return self._variation_executors
 
-    def cleanup_empty_executor_branches(self):
+    def cleanup_empty_executor_branches(self, consider_discarded=False):
         """
         This method removes all sub executors that are empty and not relevant anymore.
         """
         to_remove_executor = []
-        for cur_variation_executor in self.get_variation_executors():
+        for cur_variation_executor in self.get_variation_executors(return_discarded=consider_discarded):
             if len(cur_variation_executor.get_testcase_executors()) == 0:
                 # remove this whole executor because it has no children anymore
                 to_remove_executor.append(cur_variation_executor)

_balder/executor/setup_executor.py

@@ -5,6 +5,9 @@ from _balder.testresult import ResultState, BranchBodyResult
 from _balder.executor.basic_executor import BasicExecutor
 from _balder.executor.scenario_executor import ScenarioExecutor
 from _balder.previous_executor_mark import PreviousExecutorMark
+from _balder.controllers.setup_controller import SetupController
+from _balder.controllers.device_controller import DeviceController
+from _balder.controllers.feature_controller import FeatureController
 
 if TYPE_CHECKING:
     from _balder.setup import Setup
@@ -58,6 +61,10 @@ class SetupExecutor(BasicExecutor):
         """returns the base :class:`Setup` that belongs to this executor"""
         return self._base_setup_class
 
+    @property
+    def base_setup_controller(self) -> SetupController:
+        return SetupController.get_for(self.base_setup_class.__class__)
+
     @property
     def fixture_manager(self) -> FixtureManager:
         """returns the current active fixture manager for this executor"""
@@ -84,15 +91,43 @@ class SetupExecutor(BasicExecutor):
 
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
+    def update_inner_referenced_feature_instances(self):
+        """
+        This method ensures that all inner referenced feature instances of all devices that are used in this setup are
+        set to the correct feature instance. For every existing device, this method goes trough all assigned features
+        and checks for a inner-referenced feature. It makes sure, that every inner-referenced feature variable has the
+        final assigned setup feature that belongs to it.
+
+        # TODO check where we validate that inner references feature exists in setup
+        """
+        for cur_setup_device in self.base_setup_controller.get_all_abs_inner_device_classes():
+            # these features are subclasses of the real defined one (because they are already the replaced ones)
+            all_device_features = DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
+            all_instantiated_feature_objs_of_this_dev = [cur_feature for _, cur_feature in all_device_features.items()]
+            for _, cur_feature in all_device_features.items():
+                cur_feature_controller = FeatureController.get_for(cur_feature.__class__)
+                # now check the inner referenced features of this feature and check if that exists in the device
+                for cur_ref_feature_name, cur_ref_feature in \
+                        cur_feature_controller.get_inner_referenced_features().items():
+                    potential_candidates = [
+                        candidate_feature for candidate_feature in all_instantiated_feature_objs_of_this_dev
+                        if isinstance(candidate_feature, cur_ref_feature.__class__)]
+                    if len(potential_candidates) != 1:
+                        raise RuntimeError("found none or more than one potential replacing candidates")
+                    replacing_candidate = potential_candidates[0]
+                    # because `cur_feature` is only the object instance, the value will be overwritten only for this
+                    # 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 cleanup_empty_executor_branches(self):
+    def cleanup_empty_executor_branches(self, consider_discarded=False):
         to_remove_executor = []
         for cur_scenario_executor in self.get_scenario_executors():
-            cur_scenario_executor.cleanup_empty_executor_branches()
-            if len(cur_scenario_executor.get_variation_executors()) == 0:
+            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
                 to_remove_executor.append(cur_scenario_executor)
         for cur_scenario_executor in to_remove_executor:

_balder/executor/testcase_executor.py

@@ -7,7 +7,6 @@ import traceback
 from _balder.utils import inspect_method
 from _balder.testresult import ResultState, TestcaseResult
 from _balder.executor.basic_executor import BasicExecutor
-from _balder.previous_executor_mark import PreviousExecutorMark
 
 if TYPE_CHECKING:
     from _balder.executor.variation_executor import VariationExecutor
@@ -132,7 +131,7 @@ class TestcaseExecutor(BasicExecutor):
             return True
         return False
 
-    def cleanup_empty_executor_branches(self):
+    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.

_balder/executor/variation_executor.py

@@ -5,7 +5,7 @@ import inspect
 import logging
 from _balder.device import Device
 from _balder.connection import Connection
-from _balder.testresult import ResultState, BranchBodyResult
+from _balder.testresult import ResultState, BranchBodyResult, ResultSummary
 from _balder.executor.basic_executor import BasicExecutor
 from _balder.executor.testcase_executor import TestcaseExecutor
 from _balder.previous_executor_mark import PreviousExecutorMark
@@ -134,6 +134,7 @@ class VariationExecutor(BasicExecutor):
 
     @property
     def not_applicable_variation_exc(self) -> Union[NotApplicableVariationException, None]:
+        """holds the :class:`NotApplicableVariationException` that describes why this variation in not applicable"""
         return self._not_applicable_variation_exc
 
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
@@ -149,7 +150,6 @@ class VariationExecutor(BasicExecutor):
             self.determine_abs_variation_connections()
             self.update_scenario_device_feature_instances()
             self.update_active_vdevice_device_mappings_in_all_features()
-            self.update_inner_referenced_feature_instances()
             self.exchange_unmapped_vdevice_references()
             self.update_vdevice_referenced_feature_instances()
             self.set_conn_dependent_methods()
@@ -282,17 +282,10 @@ class VariationExecutor(BasicExecutor):
 
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
-    def testsummary(self):
+    def testsummary(self) -> ResultSummary:
         if self.can_be_applied():
             return super().testsummary()
-        return {
-            ResultState.NOT_RUN: 0,
-            ResultState.FAILURE: 0,
-            ResultState.ERROR: 0,
-            ResultState.SUCCESS: 0,
-            ResultState.SKIP: 0,
-            ResultState.COVERED_BY: 0
-        }
+        return ResultSummary()
 
     def get_testcase_executors(self) -> List[TestcaseExecutor]:
         """returns all sub testcase executors that belongs to this variation-executor"""
@@ -483,7 +476,7 @@ class VariationExecutor(BasicExecutor):
         # can not find some
         return None
 
-    def cleanup_empty_executor_branches(self):
+    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.
@@ -569,34 +562,6 @@ class VariationExecutor(BasicExecutor):
             for cur_feature, cur_original_mapping in cur_feature_mapping_dict.items():
                 cur_feature.active_vdevices = cur_original_mapping
 
-    def update_inner_referenced_feature_instances(self):
-        """
-        This method ensures that all inner referenced feature instances of the used feature object, will be replaced
-        with the related feature instances of the device object itself.
-
-        .. note::
-            Note that this method expects that the true defined scenario features are already replaced with the real
-            setup features. So the method requires that the method `update_scenario_device_feature_instances()` was
-            called before.
-        """
-        for scenario_device, _ in self._base_device_mapping.items():
-            # these features are subclasses of the real defined one (because they are already the replaced ones)
-            all_device_features = DeviceController.get_for(scenario_device).get_all_instantiated_feature_objects()
-            all_instantiated_feature_objs = [cur_feature for _, cur_feature in all_device_features.items()]
-            for _, cur_feature in all_device_features.items():
-                cur_feature_controller = FeatureController.get_for(cur_feature.__class__)
-                # now check the inner referenced features of this feature and check if that exists in the device
-                for cur_ref_feature_name, cur_ref_feature in \
-                        cur_feature_controller.get_inner_referenced_features().items():
-                    potential_candidates = [candidate_feature for candidate_feature in all_instantiated_feature_objs
-                                            if isinstance(candidate_feature, cur_ref_feature.__class__)]
-                    if len(potential_candidates) != 1:
-                        raise RuntimeError("found none or more than one potential replacing candidates")
-                    replacing_candidate = potential_candidates[0]
-                    # because `cur_feature` is only the object instance, the value will be overwritten only for this
-                    # object
-                    setattr(cur_feature, cur_ref_feature_name, replacing_candidate)
-
     def exchange_unmapped_vdevice_references(self):
         """
         This method exchanges all :class:`VDevice` references to an instance of :class:`UnmappedVDevice` if the
@@ -721,10 +686,7 @@ class VariationExecutor(BasicExecutor):
                     if cur_scenario_device not in abs_var_scenario_device_cnns.keys():
                         abs_var_scenario_device_cnns[cur_scenario_device] = {}
 
-                    if cur_cnn.from_device == cur_scenario_device:
-                        cur_to_device = cur_cnn.to_device
-                    else:
-                        cur_to_device = cur_cnn.from_device
+                    cur_to_device, _ = cur_cnn.get_conn_partner_of(cur_scenario_device)
 
                     if cur_to_device not in abs_var_scenario_device_cnns[cur_scenario_device].keys():
                         abs_var_scenario_device_cnns[cur_scenario_device][cur_to_device] = []

_balder/fixture_manager.py

@@ -394,6 +394,41 @@ class FixtureManager:
         if exception:
             raise exception
 
+    def get_fixture_for_class(
+            self,
+            execution_level: Union[Type[ExecutorTree], Type[SetupExecutor], Type[ScenarioExecutor],
+                                   Type[VariationExecutor], Type[TestcaseExecutor]],
+            setup_or_scenario_class: Union[None, Type[Setup], Type[Scenario]],
+            parent_classes: bool = True
+    ) -> List[Tuple[MethodLiteralType, Callable]]:
+        """
+        This method returns all classes of a specific Setup/Scenario class for a specific execution-level.
+
+        :param execution_level: the execution level the fixture should be returned for
+        :param setup_or_scenario_class: the scenario or setup class, the fixtures should be returned for
+        :param parent_classes: true if the method should look for fixtures in parent classes too
+        :return: list with all fixtures that are matching search criteria
+        """
+        # current relevant EXECUTION LEVEL - all other levels are not relevant for this call
+        cur_execution_level = self.resolve_type_level[execution_level]
+        # get all fixtures of the current relevant level
+        fixtures_of_exec_level = self.fixtures.get(cur_execution_level, {})
+        if setup_or_scenario_class is not None and parent_classes:
+            all_fixtures = []
+            for cur_parent_class in inspect.getmro(setup_or_scenario_class):
+                if issubclass(cur_parent_class, (Scenario, Setup)):
+                    all_fixtures += self.get_fixture_for_class(execution_level, cur_parent_class, False)
+            # go through list and remove all overwritten fixtures
+            _added_fixtures = []
+            remaining_fixtures = []
+            for cur_fixture_tuple in all_fixtures:
+                if cur_fixture_tuple[1].__name__ not in _added_fixtures:
+                    _added_fixtures.append(cur_fixture_tuple[1].__name__)
+                    remaining_fixtures.append(cur_fixture_tuple)
+            return remaining_fixtures
+        else:
+            return fixtures_of_exec_level.get(setup_or_scenario_class, [])
+
     def get_all_fixtures_for_current_level(
             self, branch: Union[ExecutorTree, SetupExecutor, ScenarioExecutor, VariationExecutor, TestcaseExecutor]) \
             -> Dict[Union[Type[ExecutorTree], Type[Scenario], Type[Setup]],
@@ -416,28 +451,24 @@ class FixtureManager:
                  argument (this list is ordered after the call hierarchy)
         """
         from _balder.executor.executor_tree import ExecutorTree
-        # current relevant EXECUTION LEVEL - all other levels are not relevant for this call
-        cur_execution_level = self.resolve_type_level[branch.__class__]
-        # get all fixtures of the current relevant level
-        fixtures_of_exec_level = self.fixtures.get(cur_execution_level, {})
 
         all_fixtures = {}
         # get all relevant fixtures of `balderglob.py` (None is key for balderglob fixtures)
-        glob_fixtures = fixtures_of_exec_level.get(None, [])
+        glob_fixtures = self.get_fixture_for_class(branch.__class__, None)
         all_fixtures[ExecutorTree] = {}
         all_fixtures[ExecutorTree][ExecutorTree] = glob_fixtures
         # get all relevant fixtures with definition scope "setup"
         all_fixtures[Setup] = {}
         for cur_setup in branch.get_all_base_instances_of_this_branch(Setup, only_runnable_elements=True):
             # check if there exists fixtures for the current setup
-            cur_setup_fixtures = fixtures_of_exec_level.get(cur_setup.__class__, [])
+            cur_setup_fixtures = self.get_fixture_for_class(branch.__class__, cur_setup.__class__)
             if cur_setup_fixtures:
                 all_fixtures[Setup][cur_setup.__class__] = cur_setup_fixtures
 
         # get all relevant fixtures with definition scope "scenario"
         all_fixtures[Scenario] = {}
         for cur_scenario in branch.get_all_base_instances_of_this_branch(Scenario, only_runnable_elements=True):
-            cur_scenario_fixtures = fixtures_of_exec_level.get(cur_scenario.__class__, [])
+            cur_scenario_fixtures = self.get_fixture_for_class(branch.__class__, cur_scenario.__class__)
             if cur_scenario_fixtures:
                 all_fixtures[Scenario][cur_scenario.__class__] = cur_scenario_fixtures
 

_balder/routing_path.py

@@ -284,8 +284,6 @@ class RoutingPath:
 
         if elem_before is not None:
             # check if device and nodes of the two elements are the same -> have to be a chain
-            last_device, last_node_name = self._get_end_device_and_node()
-
             if isinstance(elem, Connection):
                 if (self.end_device, self.end_node_name) not in \
                         [(elem.from_device, elem.from_node_name), (elem.to_device, elem.to_node_name)]:

_balder/solver.py

@@ -170,10 +170,14 @@ class Solver:
         self._mapping = initial_mapping
         self._resolving_was_executed = True
 
-    def get_executor_tree(self, plugin_manager: PluginManager) -> ExecutorTree:  # pylint: disable=unused-argument
+    # pylint: disable-next=unused-argument
+    def get_executor_tree(self, plugin_manager: PluginManager, add_discarded=False) -> ExecutorTree:
         """
         This method builds the ExecutorTree from the resolved data and returns it
 
+        :param plugin_manager: the related plugin manager object
+        :param add_discarded: True in case discarded elements should be added to the tree, otherwise False
+
         :return: the executor tree is built on the basis of the mapping data
         """
 
@@ -215,7 +219,7 @@ class Solver:
         # now filter all elements that have no child elements
         #   -> these are items that have no valid matching, because no variation can be applied for it (there are no
         #      required :class:`Feature` matching or there exists no possible routing for the variation)
-        executor_tree.cleanup_empty_executor_branches()
+        executor_tree.cleanup_empty_executor_branches(consider_discarded=add_discarded)
 
         self._set_data_for_covered_by_in_tree(executor_tree=executor_tree)
 

_balder/testresult.py

@@ -1,4 +1,6 @@
 from __future__ import annotations
+
+from dataclasses import dataclass, fields
 from typing import TYPE_CHECKING, List, Union
 
 from enum import Enum
@@ -12,21 +14,21 @@ class ResultState(Enum):
     enumeration that describes the possible results of a testcase-/fixture-executor
     """
     # this state will be assigned if the executor doesn't run yet
-    NOT_RUN = 'NOT_RUN'
+    NOT_RUN = 'not_run'
     # this state will be assigned if the test fails (only assignable to :class:`TestcaseExecutor`)
-    FAILURE = 'FAILURE'
+    FAILURE = 'failure'
     # this state will be assigned if the executor can not be executed because the fixture fails (only possible in
     # construction part of fixtures, if the error occurs in teardown the next higher executer get this state) - will be
     # assigned to the executor which has the fixture that fails
-    ERROR = 'ERROR'
+    ERROR = 'error'
     # this state will be assigned if the executor was executed successfully (session fixture and teardown fixture; for
     # :class:`TestcaseExecutor` also the testcase itself)
-    SUCCESS = 'SUCCESS'
+    SUCCESS = 'success'
     # this state will be assigned if the executor was skipped
-    SKIP = 'SKIP'
+    SKIP = 'skip'
     # this state will be assigned if the executor is covered by another executor and wasn't executed (only assignable
     # to :class:`ScenarioExecutor` and :class:`TestcaseExecutor`)
-    COVERED_BY = 'COVERED_BY'
+    COVERED_BY = 'covered_by'
 
     @staticmethod
     def priority_order() -> List[ResultState]:
@@ -128,3 +130,33 @@ class TestcaseResult(_SettableResult):
     #: contains the possible values that can be set for this Result type
     ALLOWED_STATES = [ResultState.NOT_RUN, ResultState.FAILURE, ResultState.SUCCESS, ResultState.SKIP,
                       ResultState.COVERED_BY]
+
+@dataclass
+class ResultSummary:
+    """
+    object that holds the test results for multiple tests like on branch or global level
+    """
+    # this state will be assigned if the executor doesn't run yet
+    not_run: int = 0
+    # this state will be assigned if the test fails (only assignable to :class:`TestcaseExecutor`)
+    failure: int = 0
+    # this state will be assigned if the executor can not be executed because the fixture fails (only possible in
+    # construction part of fixtures, if the error occurs in teardown the next higher executer get this state) - will be
+    # assigned to the executor which has the fixture that fails
+    error: int = 0
+    # this state will be assigned if the executor was executed successfully (session fixture and teardown fixture; for
+    # :class:`TestcaseExecutor` also the testcase itself)
+    success: int = 0
+    # this state will be assigned if the executor was skipped
+    skip: int = 0
+    # this state will be assigned if the executor is covered by another executor and wasn't executed (only assignable
+    # to :class:`ScenarioExecutor` and :class:`TestcaseExecutor`)
+    covered_by: int = 0
+
+    def __add__(self, other) -> ResultSummary:
+        new_summary = ResultSummary()
+        for cur_field in fields(self.__class__):
+            self_val = getattr(self, cur_field.name)
+            other_val = getattr(other, cur_field.name)
+            setattr(new_summary, cur_field.name, self_val + other_val)
+        return new_summary

{baldertest-0.1.0b7.dist-info → baldertest-0.1.0b9.dist-info}/METADATA

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

{baldertest-0.1.0b7.dist-info → baldertest-0.1.0b9.dist-info}/RECORD

@@ -1,10 +1,10 @@
 _balder/__init__.py,sha256=Qk4wkVInPlXLFV36Yco5K7PDawJoeeWQVakzj6g5pmA,195
-_balder/_version.py,sha256=Mlz6U-dFHSBS29dqTLVb3_npm2vadOIIiwZaPdAO_Ag,162
+_balder/_version.py,sha256=xdDxoDc8nbJHb9-aJOnXPcJO9u_wtajm1m932_7HjoI,413
 _balder/balder_plugin.py,sha256=EQzJP1dwwVDydhMLJtAmTCXOczlDuXBJur05lalmK_k,3136
-_balder/balder_session.py,sha256=bgpgvpYqFmtUlPFYEXQ10Mvj0IhLO86Yut__Gmc3l2c,16211
+_balder/balder_session.py,sha256=WPOcarZQhTzMeAQt-hRqI8GtXN5TdMIqzyhgYD2h4rw,16079
 _balder/balder_settings.py,sha256=U96PVep7dGSaTXrMfeZMYf6oCIcEDPEqrBlFcoX476s,582
-_balder/collector.py,sha256=PfGVY34wrz2oauDEu-HY53S7w5HlQoaYwuNHQE0HuRk,40336
-_balder/connection.py,sha256=T2g63SbtTRT7d8MvabTSbPQYP9DhIhn2zo8zc54OwoY,69633
+_balder/collector.py,sha256=T_7LO8ZNty8EyOmM-U-uhU9-umdAv1fbuMVNjQWUwj0,42156
+_balder/connection.py,sha256=MNazK97CIEJCA4o1krjKjtilVhOYMWD8TZT0YT5nCJs,71778
 _balder/decorator_connect.py,sha256=TvyJNIslBAYVQWhsfSeFgXKp_DP7sZF1BmcP6RhIdKo,5988
 _balder/decorator_covered_by.py,sha256=Y6WMUuyn_uvFkjGfbts8OE5Bsir_7LTRB-jxYGaYk4Y,4069
 _balder/decorator_fixture.py,sha256=Nvr3H-r8LlPiGSGEst3D1M-KQaBqSA1u1u13qzZrSwk,1138
@@ -15,15 +15,15 @@ _balder/device.py,sha256=5O3tqj_iLKfHb5Zi_viJ76VH82cMOzX58OzRrMRRv0k,833
 _balder/exceptions.py,sha256=d0YSw8zVax2bFakG_1hcLlAXlyQh5jXnOuIPL1HLfI4,4202
 _balder/exit_code.py,sha256=P0oFWKfjMo36Frv13ADRcm8eSPN3kE-WmZBE9qZJHdA,513
 _balder/feature.py,sha256=B3yPc-WZwLt1Q4dO9s2j9g1MBTcMBjn6oWoLnRgrwSs,3845
-_balder/fixture_manager.py,sha256=rsepVAp0BRbakcwWtY59NtFDipTLvFVxPqJoCXYrliM,26843
+_balder/fixture_manager.py,sha256=_fJZAaBK8Pej96juvdkigi7rjKJ-RTbfxhkSs78OBvg,28656
 _balder/node_gateway.py,sha256=64mv7Nx82JVknnQ09UXC-AcdDl6i_OB6NOsq_uBxeYo,4710
 _balder/plugin_manager.py,sha256=Ev2jnx4NtFHDsZ3C6h0HrJtQisqLO-V34JRM3wzTnFM,6921
 _balder/previous_executor_mark.py,sha256=gwpGu7d-kwPzQT8CmaPfuEG6fess2Upf5Q-zX6Oi6NY,835
-_balder/routing_path.py,sha256=7geuwPqBVnB-wAZ1-CjSLedNClVWb5rS628u8fRbvFw,17247
+_balder/routing_path.py,sha256=6MJkhzBTHow2ESXzKQ2otwRFbPcKhLTYVy-zh7c5HeE,17172
 _balder/scenario.py,sha256=ATowBUl2HYQBmJHZ-eBpliqjPsWPnZAme9kwIeX3Tak,840
 _balder/setup.py,sha256=zSgtzNIWTVBjiZ5mn-qfpqIAnP3Im73t3Lqoaw0gWEI,763
-_balder/solver.py,sha256=m4BiQxnTG7qsKlSM6tSpVFICocRohUyTH729VcM5QqE,11764
-_balder/testresult.py,sha256=6yo3EcuLlpM23vdrYzn5VDcG35qelAQudmyoLpwZoHM,5251
+_balder/solver.py,sha256=qgcCRyLg3nsO2d3H0pukxmm2oe_h6t0pBGyZ-FgQYKc,11998
+_balder/testresult.py,sha256=byJD3F84TNH40k30pjnxeLHXAAE-lqbVlk1JOSBtdNo,6783
 _balder/unmapped_vdevice.py,sha256=oKr01YVTLViWtZkYz8kx8ccTx-KmwgNrHuQqqD4eLQw,513
 _balder/utils.py,sha256=2kcX6bZIJW9Z8g-Hv0ue2mdOLBQYq4T2XSZpH2in1MQ,3092
 _balder/vdevice.py,sha256=fc2xuMnTuN1RyfWh9mqFgLdSO9yGA75eERobTXUQ9JA,215
@@ -33,18 +33,18 @@ _balder/controllers/__init__.py,sha256=UNb6QzMj4TqPI15OSvXyUJlA-NSai0CKkQhV5JIsb
 _balder/controllers/base_device_controller.py,sha256=g-vY2SqKFUC9yGOvHLfbdmILT3sK2YyaWKSfvTRcC0o,3174
 _balder/controllers/controller.py,sha256=XGRE5LKWxxftEf-bZODvKxXwULu09iG131wMwRoz4Fk,803
 _balder/controllers/device_controller.py,sha256=bT8c0_9UmrAmzuZ-dsleSnw2pIppfITDG4ttEZjWlC8,23477
-_balder/controllers/feature_controller.py,sha256=Dsjdbcs6OFQZDCJjOstqOghr3S88u-RdJkXukZHHDfU,42427
-_balder/controllers/normal_scenario_setup_controller.py,sha256=mJdqMP7xlhtloQgKBAmgWe5a-oyYqmruUKiL-rLOe08,22144
+_balder/controllers/feature_controller.py,sha256=jaIbKbiEOdYRpYWuGdaByQBtlThK-u7OAr_xYhAfnEg,43737
+_balder/controllers/normal_scenario_setup_controller.py,sha256=cF2U-tC3LEyWdZDqZP_mN3Q_7uIzg9jiY_J--Pi5kk8,21877
 _balder/controllers/scenario_controller.py,sha256=gpN_wxEYcHlh6DVk7pRbPj_x2cmM6iIAskcpLstQo2g,17973
 _balder/controllers/setup_controller.py,sha256=iNIMFjawYJWaSToUUfpmRK6ssycPyZGNlcvms8c7GKM,7135
 _balder/controllers/vdevice_controller.py,sha256=6-PidCKgvUteZVJsbGkKX69f3cYYYnolONl5Gja16W8,5777
 _balder/executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-_balder/executor/basic_executor.py,sha256=ujG5HMu7dZMmpFA3EHDpi3mBIW-b_kWtzsJFK1Dy9-I,11480
-_balder/executor/executor_tree.py,sha256=cwhdM4rdvf52B4DFT9IdZhWh4TW3Dd4BlyZevFH-Yew,9687
-_balder/executor/scenario_executor.py,sha256=stAi1ulXxa60XND5Ot8jXRG_4tGGHKI31EyuNNPiwYE,10807
-_balder/executor/setup_executor.py,sha256=z6naHYh4kzkAR3RuRjTymstuJ6lic-iKM7rWx6jNgzM,5747
-_balder/executor/testcase_executor.py,sha256=VVQsMu15w3IYhPt4nvWfcQIH_RM1BHyJfUs4amOUxWI,6677
-_balder/executor/variation_executor.py,sha256=gSqQCTZkQwKvll_9yWP65cmUYR_egniG4gntraj_JSE,55374
+_balder/executor/basic_executor.py,sha256=PYuQ1TKXKnbnQirCmayjDSyPyBmqJws1HWqkHmGKZtw,11137
+_balder/executor/executor_tree.py,sha256=nEZ2bwWuayPZQrGSucFiDzuFSrYDnUVzqnVCtDLq2Ys,10439
+_balder/executor/scenario_executor.py,sha256=3j5lAFCA4zCxhivjMPFGlWMi_ieZGkdwnZ_JQoAt4Rw,11094
+_balder/executor/setup_executor.py,sha256=FsPTPsXZMoVB7xibEpCcwjC-BpkfGVZmx5lVbuebduw,8326
+_balder/executor/testcase_executor.py,sha256=jNfACO-AuOktIgCVcsavh0rHbUr5MmI-jML-LPMvo0w,6639
+_balder/executor/variation_executor.py,sha256=Ms8dfZPIL5-sYzMg2c1-WANDz8ZBHqNHXgegDobm7Gg,53106
 _balder/objects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 _balder/objects/connections/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 _balder/objects/connections/osi_1_physical.py,sha256=74lKWJd6ETEtvNXH0_dmTbkZlStJ_af218pQkUht0aA,2189
@@ -60,9 +60,9 @@ balder/__init__.py,sha256=BfbdkW_CZCXWGqtdg1gpAjO0AY8b4h-P-flWsIMG-X0,1003
 balder/connections.py,sha256=H6rf7UsiVY_FeZLngZXCT9WDw9cQqpiDiPbz_0J4yjM,2331
 balder/devices.py,sha256=zupHtz8yaiEjzR8CrvgZU-RzsDQcZFeN5mObfhtjwSw,173
 balder/exceptions.py,sha256=z_vlipJIsFwwJy9Ae_oGDJGPTINiAInMNZuCvEy6SUE,1884
-baldertest-0.1.0b7.dist-info/LICENSE,sha256=Daz9qTpqbiq-klWb2Q9lYOmn3rJ5oIQnbs62sGcqOZ4,1084
-baldertest-0.1.0b7.dist-info/METADATA,sha256=wB5TDyLXJNzyQvWmXqxuCD5VB9Voum3iTtY06jpFjlk,15783
-baldertest-0.1.0b7.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-baldertest-0.1.0b7.dist-info/entry_points.txt,sha256=hzqu_nrMKTCi5IJqzS1fhIXWEiL7mTGZ-kgj2lUYlRU,65
-baldertest-0.1.0b7.dist-info/top_level.txt,sha256=RUkIBkNLqHMemx2C9aEpoS65dpqb6_jU-oagIPxGQEA,15
-baldertest-0.1.0b7.dist-info/RECORD,,
+baldertest-0.1.0b9.dist-info/LICENSE,sha256=Daz9qTpqbiq-klWb2Q9lYOmn3rJ5oIQnbs62sGcqOZ4,1084
+baldertest-0.1.0b9.dist-info/METADATA,sha256=HzdUqwAR2FIIYoAWg6RxXoFOJzUOqpkxcA7q-V3SHbM,15783
+baldertest-0.1.0b9.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+baldertest-0.1.0b9.dist-info/entry_points.txt,sha256=hzqu_nrMKTCi5IJqzS1fhIXWEiL7mTGZ-kgj2lUYlRU,65
+baldertest-0.1.0b9.dist-info/top_level.txt,sha256=RUkIBkNLqHMemx2C9aEpoS65dpqb6_jU-oagIPxGQEA,15
+baldertest-0.1.0b9.dist-info/RECORD,,

{baldertest-0.1.0b7.dist-info → baldertest-0.1.0b9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
+Generator: setuptools (70.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any