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

_balder/executor/variation_executor.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
-from typing import Type, Union, List, Dict, Tuple, TYPE_CHECKING
+
+from typing import Type, Union, List, Dict, TYPE_CHECKING
 
 import inspect
 import logging
+from _balder.cnnrelations import OrConnectionRelation
 from _balder.device import Device
 from _balder.connection import Connection
+from _balder.feature_replacement_mapping import FeatureReplacementMapping
 from _balder.fixture_execution_level import FixtureExecutionLevel
 from _balder.testresult import ResultState, BranchBodyResult, ResultSummary
 from _balder.executor.basic_executable_executor import BasicExecutableExecutor
@@ -13,6 +16,7 @@ from _balder.executor.unresolved_parametrized_testcase_executor import Unresolve
 from _balder.previous_executor_mark import PreviousExecutorMark
 from _balder.routing_path import RoutingPath
 from _balder.unmapped_vdevice import UnmappedVDevice
+from _balder.feature_vdevice_mapping import FeatureVDeviceMapping
 from _balder.controllers import DeviceController, VDeviceController, FeatureController, NormalScenarioSetupController
 from _balder.exceptions import NotApplicableVariationException, UnclearAssignableFeatureConnectionError
 
@@ -20,7 +24,8 @@ if TYPE_CHECKING:
     from _balder.setup import Setup
     from _balder.feature import Feature
     from _balder.scenario import Scenario
-    from _balder.vdevice import VDevice
+    from _balder.controllers.scenario_controller import ScenarioController
+    from _balder.controllers.setup_controller import SetupController
     from _balder.executor.scenario_executor import ScenarioExecutor
     from _balder.fixture_manager import FixtureManager
 
@@ -45,12 +50,10 @@ class VariationExecutor(BasicExecutableExecutor):
         self._routings: Dict[Connection, List[RoutingPath]] = {}
         # buffer variable to save the feature replacement after it was determined with
         # `determine_feature_replacement_and_vdevice_mappings()`
-        self._feature_replacement: \
-            Union[None, Dict[Type[Device], Dict[str, Tuple[Union[Feature, None], Feature]]]] = None
+        self._feature_replacement: Union[None, Dict[Type[Device], FeatureReplacementMapping]] = None
         # buffer variable to save the feature replacement after it was determined with
         # `determine_feature_replacement_and_vdevice_mappings()`
-        self._abs_setup_feature_vdevice_mappings: \
-            Union[None, Dict[Type[Device], Dict[Feature, Dict[Type[VDevice], Type[Device]]]]] = None
+        self._abs_setup_feature_vdevice_mappings: Union[None, Dict[Type[Device], FeatureVDeviceMapping]] = None
 
         # contains the absolute scenario device connections for the current variation
         self._abs_variation_scenario_device_connections: Union[List[Connection], None] = None
@@ -62,8 +65,7 @@ class VariationExecutor(BasicExecutableExecutor):
         # contains the original active vdevice mappings for all scenario and setup devices (will be managed by
         # `update_active_vdevice_device_mappings_in_scenario_and_setup_devices()` and
         # `revert_active_vdevice_device_mappings_in_scenario_and_setup_devices()`)
-        self._original_active_vdevice_mappings: \
-            Dict[Type[Device], Dict[Feature, Dict[Type[VDevice], Type[Device]]]] = {}
+        self._original_active_vdevice_mappings: Dict[Type[Device], FeatureVDeviceMapping] = {}
 
         # is True if the applicability check was done
         self._applicability_check_done = False
@@ -96,11 +98,25 @@ class VariationExecutor(BasicExecutableExecutor):
         """property returns the current :class:`Scenario` for this variation"""
         return self._parent_executor.base_scenario_class
 
+    @property
+    def cur_scenario_controller(self) -> ScenarioController:
+        """
+        returns the current :class:`ScenarioController` for this variation
+        """
+        return self._parent_executor.base_scenario_controller
+
     @property
     def cur_setup_class(self) -> Setup:
         """property returns the current :class:`Setup` for this variation"""
         return self._parent_executor.parent_executor.base_setup_class
 
+    @property
+    def cur_setup_controller(self) -> SetupController:
+        """
+        returns the current :class:`SetupController` for this variation
+        """
+        return self._parent_executor.parent_executor.base_setup_controller
+
     @property
     def base_device_mapping(self) -> Dict[Type[Device], Type[Device]]:
         """
@@ -119,18 +135,17 @@ class VariationExecutor(BasicExecutableExecutor):
         return self._fixture_manager
 
     @property
-    def feature_replacement(self) -> Dict[Type[Device], Dict[str, Tuple[Union[Feature, None], Feature]]]:
+    def feature_replacement(self) -> Dict[Type[Device], FeatureReplacementMapping]:
         """
-        this property is a dictionary with every scenario device as key and a dictionary as value - the value dictionary
-        contains a tuple (inner dict value) for every attribute name(inner dict key) - the tuples always consist of two
-        elements, the old feature as first item of the tuple (the instantiated feature from the scenario if it exists,
-        otherwise this is None) and the new feature as second item (the feature of the related Setup-Device)
+        this property is a dictionary with every scenario device as key and feature-replacement-mapping as value - the
+        mappings hold at least information about the attribute name of the feature in scenario device, the old
+        scenario-feature the instantiated feature from the scenario if it exists, otherwise this is None) and the
+        new feature as second item (the feature of the related Setup-Device)
         """
         return self._feature_replacement
 
     @property
-    def abs_setup_feature_vdevice_mappings(self) \
-            -> Dict[Type[Device], Dict[Feature, Dict[Type[VDevice], Type[Device]]]]:
+    def abs_setup_feature_vdevice_mappings(self) -> Dict[Type[Device], FeatureVDeviceMapping]:
         """returns the feature replacement that was determined with
         `determine_feature_replacement_and_vdevice_mappings()`"""
         return self._abs_setup_feature_vdevice_mappings
@@ -211,26 +226,22 @@ class VariationExecutor(BasicExecutableExecutor):
         vDevices-Mappings (so the mapped setup-devices) implements all features that are defined in the vDevices
         """
 
-        for cur_scenario_device, cur_replacement_dict in self.feature_replacement.items():
+        for cur_scenario_device, cur_replacement_mapping in self.feature_replacement.items():
             cur_setup_device = self.get_setup_device_for(scenario_device=cur_scenario_device)
             all_inner_setup_features = \
                 DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
 
-            # describes the mapping from the new setup feature (key) to the instantiated scenario feature (value)
-            #  note that this dictionary only contains the required one
-            setup_to_scenario_feature_mapping: Dict[Type[Feature], Feature] = {
-                cur_replacement_tuple[1]: cur_replacement_tuple[0]
-                for cur_attr_name, cur_replacement_tuple in cur_replacement_dict.items()
-                if cur_replacement_tuple[0] is not None}
-
             # now secure that all features are available in the corresponding setup device, that are defined in the
             #  mapped vDevice
             for _, cur_setup_feature_obj in all_inner_setup_features.items():
-                # only check if there is a requirement of this feature (the feature is required by the Scenario)
-                if cur_setup_feature_obj.__class__ not in setup_to_scenario_feature_mapping.keys():
-                    # ignore this, because no requirement for this feature
+                related_scenario_feature_obj = \
+                    cur_replacement_mapping.get_replaced_scenario_feature_for(cur_setup_feature_obj)
+
+                # only check if this feature is required by the scenario
+                if related_scenario_feature_obj is None:
+                    # ignore this, because this feature is not used in the scenario
                     continue
-                related_scenario_feature_obj = setup_to_scenario_feature_mapping[cur_setup_feature_obj.__class__]
+
                 # get vDevice and device mapping
                 partner_scenario_vdevice, partner_scenario_device = \
                     related_scenario_feature_obj.active_vdevice_device_mapping
@@ -239,7 +250,7 @@ class VariationExecutor(BasicExecutableExecutor):
                     # ignore because no mapping exist here
                     continue
 
-                partner_setup_device = self.get_setup_device_for(scenario_device=partner_scenario_vdevice)
+                partner_setup_device = self.get_setup_device_for(scenario_device=partner_scenario_device)
                 # get the related vDevice on setup view that is currently active
                 mapped_setup_vdevices = [
                     cur_vdevice for cur_vdevice
@@ -284,6 +295,39 @@ class VariationExecutor(BasicExecutableExecutor):
                     f'can not find a valid routing on setup level for the connection `{scenario_cnn.get_tree_str()}` '
                     f'between scenario devices `{scenario_cnn.from_device}` and `{scenario_cnn.to_device}`')
 
+    def _get_matching_setup_features_for(
+            self,
+            scenario_feature_obj: Feature,
+            in_setup_device: Type[Device]
+    ) -> List[Feature]:
+        """
+        Helper method that returns all matching setup features for the provided scenario feature in the provided setup
+        device.
+        """
+        cur_setup_features = DeviceController.get_for(in_setup_device).get_all_instantiated_feature_objects()
+
+        replacing_feature_candidates = [
+            cur_setup_feature for cur_setup_feature in cur_setup_features.values()
+            if isinstance(cur_setup_feature, scenario_feature_obj.__class__)
+        ]
+        active_scenario_vdev, mapped_scenario_dev = scenario_feature_obj.active_vdevice_device_mapping
+
+        replacing_features = replacing_feature_candidates.copy()
+        if mapped_scenario_dev is not None:
+            # get the related setup device for the mapped scenario device (on scenario level)
+            setup_dev_of_mapped_scenario_dev = self.get_setup_device_for(mapped_scenario_dev)
+
+            # now check if there is a mapping on setup level too
+            for cur_replacing_feature in replacing_feature_candidates:
+                mapped_setup_vdev, mapped_setup_dev = cur_replacing_feature.active_vdevice_device_mapping
+                if mapped_setup_vdev is not None and not issubclass(mapped_setup_vdev, active_scenario_vdev):
+                    # drop this feature matching, because we have different vdevice mapped
+                    replacing_features.remove(cur_replacing_feature)
+                elif mapped_setup_dev is not None and mapped_setup_dev != setup_dev_of_mapped_scenario_dev:
+                    # drop this feature matching, because it is not applicable here
+                    replacing_features.remove(cur_replacing_feature)
+        return replacing_features
+
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
     def testsummary(self) -> ResultSummary:
@@ -336,75 +380,58 @@ class VariationExecutor(BasicExecutableExecutor):
         :raises NotApplicableVariationError: will be thrown if this variation cannot be applied, because the setup-/
                                              scenario-device-features can not be resolved
         """
-        feature_replacement = {}
-        abs_setup_vdevice_mappings = {}
+        feature_replacement = {
+            scenario_dev: FeatureReplacementMapping() for scenario_dev in self.base_device_mapping.keys()
+        }
+
+        abs_setup_vdevice_mappings = {
+            setup_dev: FeatureVDeviceMapping() for setup_dev in self.base_device_mapping.values()
+        }
         for cur_scenario_device, cur_setup_device in self.base_device_mapping.items():
             cur_setup_features = DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
 
-            if cur_scenario_device not in feature_replacement.keys():
-                feature_replacement[cur_scenario_device] = {}
+            all_assigned_setup_features = []
+            cur_scenario_device_features = \
+                DeviceController.get_for(cur_scenario_device).get_all_instantiated_feature_objects()
+            for cur_attr_name, cur_scenario_feature_obj in cur_scenario_device_features.items():
+                active_scenario_vdevice, mapped_scenario_device = cur_scenario_feature_obj.active_vdevice_device_mapping
 
-            if cur_setup_device not in abs_setup_vdevice_mappings.keys():
-                abs_setup_vdevice_mappings[cur_setup_device] = {}
+                cur_setup_feature_objs = self._get_matching_setup_features_for(
+                    scenario_feature_obj=cur_scenario_feature_obj, in_setup_device=cur_setup_device
+                )
 
-            all_assigned_setup_features = []
-            cur_scenario_device_orig_features = \
-                DeviceController.get_for(cur_scenario_device).get_original_instanced_feature_objects()
-            for cur_attr_name, cur_abstract_scenario_feature_obj in cur_scenario_device_orig_features.items():
-                replacing_features = [cur_setup_feature for _, cur_setup_feature in cur_setup_features.items()
-                                      if isinstance(cur_setup_feature, cur_abstract_scenario_feature_obj.__class__)]
-                used_scenario_vdevice, mapped_scenario_device = \
-                    cur_abstract_scenario_feature_obj.active_vdevice_device_mapping
-                # check if there is a mapped device in scenario level
-                cleanup_replacing_features = replacing_features.copy()
-                if mapped_scenario_device is not None:
-                    # get the related setup device for the mapped scenario device (on scenario level)
-                    to_scenarios_vdevice_mapped_setup_device = self.get_setup_device_for(mapped_scenario_device)
-
-                    # now check if there is a mapping on setup level too
-                    for cur_replacing_feature in replacing_features:
-                        mapped_setup_vdevice, mapped_setup_device = cur_replacing_feature.active_vdevice_device_mapping
-                        if mapped_setup_vdevice is not None and \
-                                not issubclass(mapped_setup_vdevice, used_scenario_vdevice):
-                            # drop this feature matching, because we have different vdevice mapped
-                            cleanup_replacing_features.remove(cur_replacing_feature)
-                        elif mapped_setup_device is not None and \
-                                mapped_setup_device != to_scenarios_vdevice_mapped_setup_device:
-                            # drop this feature matching, because it is not applicable here
-                            cleanup_replacing_features.remove(cur_replacing_feature)
-
-                if len(cleanup_replacing_features) != 1:
+                if len(cur_setup_feature_objs) != 1:
                     raise NotApplicableVariationException(
                         f'this variation can not be applicable because there was no setup feature implementation of '
-                        f'`{cur_abstract_scenario_feature_obj.__class__.__name__}` (used by scenario device '
+                        f'`{cur_scenario_feature_obj.__class__.__name__}` (used by scenario device '
                         f'`{cur_scenario_device.__name__}`) in setup device `{cur_setup_device.__name__}`')
+                cur_setup_feature_obj = cur_setup_feature_objs[0]
 
                 if mapped_scenario_device is None:
                     # we have exactly one matching candidate, but also no vDevice mapping
                     # check if the matching candidate has a vDevice mapping
-                    _, mapped_setup_device = cleanup_replacing_features[0].active_vdevice_device_mapping
-                    cleanup_feature_controller = FeatureController.get_for(cleanup_replacing_features[0].__class__)
+                    _, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
+                    cleanup_feature_controller = FeatureController.get_for(cur_setup_feature_obj.__class__)
                     if mapped_setup_device is None \
                             and len(cleanup_feature_controller.get_abs_inner_vdevice_classes()) > 0:
                         # there is no vDevice mapping on scenario and no vDevice mapping on setup level, but the
                         # feature defined vDevices -> NOT APPLICABLE
                         logger.warning(
                             f"missing vDevice mapping for feature "
-                            f"`{cur_abstract_scenario_feature_obj.__class__.__name__}` (used in scenario device "
+                            f"`{cur_scenario_feature_obj.__class__.__name__}` (used in scenario device "
                             f"`{cur_scenario_device.__name__}` and in setup device `{cur_setup_device.__name__}`) - "
                             f"VARIATION CAN NOT BE APPLIED")
                         raise NotApplicableVariationException(
-                            f'this variation can not be applicable because there was no vDevice mapping given on '
+                            f'this variation can not be applied because there was no vDevice mapping given on '
                             f'scenario or on setup level for the feature '
-                            f'`{cur_abstract_scenario_feature_obj.__class__.__name__}` (used by scenario device '
+                            f'`{cur_scenario_feature_obj.__class__.__name__}` (used by scenario device '
                             f'`{cur_scenario_device.__name__}`) in setup device `{cur_setup_device.__name__}`')
 
-                all_assigned_setup_features.append(cleanup_replacing_features[0])
-                if cur_attr_name not in feature_replacement[cur_scenario_device].keys():
-                    cleanup_feature = cleanup_replacing_features[0]
-                    cleanup_feature_controller = FeatureController.get_for(cleanup_feature.__class__)
+                all_assigned_setup_features.append(cur_setup_feature_obj)
+                if cur_attr_name not in feature_replacement[cur_scenario_device].attr_names:
+                    cleanup_feature_controller = FeatureController.get_for(cur_setup_feature_obj.__class__)
 
-                    used_setup_vdevice, mapped_setup_device = cleanup_feature.active_vdevice_device_mapping
+                    used_setup_vdevice, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
 
                     # if there is a vDevice mapping on scenario level, but not on setup level, so update the
                     # VDevice-Device-Mapping there
@@ -413,29 +440,44 @@ class VariationExecutor(BasicExecutableExecutor):
                         # because check was already done in collector-stage)
                         setup_vdevices = [cur_vdevice for cur_vdevice
                                           in cleanup_feature_controller.get_abs_inner_vdevice_classes()
-                                          if cur_vdevice.__name__ == used_scenario_vdevice.__name__]
+                                          if cur_vdevice.__name__ == active_scenario_vdevice.__name__]
                         used_setup_vdevice = setup_vdevices[0]
                         # set the mapping
-                        abs_setup_vdevice_mappings[cur_setup_device][cleanup_feature] = {
-                            used_setup_vdevice: self.get_setup_device_for(mapped_scenario_device)}
+                        abs_setup_vdevice_mappings[cur_setup_device].add(
+                            feature=cur_setup_feature_obj,
+                            mappings={
+                                used_setup_vdevice: self.get_setup_device_for(mapped_scenario_device)
+                            }
+                        )
                     # if there is a vDevice mapping on setup level, but not on scenario level, so directly update the
                     # VDevice-Device-Mapping there
                     elif mapped_scenario_device is None and mapped_setup_device is not None:
-                        abs_setup_vdevice_mappings[cur_setup_device][cleanup_feature] = {
-                            used_setup_vdevice: mapped_setup_device}
+                        abs_setup_vdevice_mappings[cur_setup_device].add(
+                            feature=cur_setup_feature_obj,
+                            mappings={
+                                used_setup_vdevice: mapped_setup_device
+                            }
+                        )
+
+                    feature_replacement[cur_scenario_device].add(attr_name=cur_attr_name,
+                                                                 scenario_feature=cur_scenario_feature_obj,
+                                                                 setup_feature=cur_setup_feature_obj)
 
-                    feature_replacement[cur_scenario_device][cur_attr_name] = \
-                        (cur_abstract_scenario_feature_obj, cleanup_feature)
             # also add all setup features that are not assigned as autonomous features
-            for _, cur_setup_feature in cur_setup_features.items():
+            for cur_setup_feature in cur_setup_features.values():
                 if cur_setup_feature not in all_assigned_setup_features:
                     # determine free name
                     idx = 0
                     autonomous_name = None
-                    while autonomous_name is None or autonomous_name in feature_replacement[cur_scenario_device].keys():
+                    while (autonomous_name is None
+                           or autonomous_name in feature_replacement[cur_scenario_device].attr_names):
                         autonomous_name = f"_autonomous_feat_{idx}"
                         idx += 1
-                    feature_replacement[cur_scenario_device][autonomous_name] = (None, cur_setup_feature)
+                    feature_replacement[cur_scenario_device].add(
+                        attr_name=autonomous_name,
+                        scenario_feature=None,
+                        setup_feature=cur_setup_feature
+                    )
 
         # set the result to internal properties
         self._feature_replacement = feature_replacement
@@ -501,20 +543,18 @@ class VariationExecutor(BasicExecutableExecutor):
         This method ensures that the (mostly abstract) feature instances of a scenario are exchanged with the
         feature instances of the assigned setup devices
         """
-        for cur_scenario_device, cur_replacement_dict in self.feature_replacement.items():
-            for cur_attr_name, cur_replacement_tuple in cur_replacement_dict.items():
-                _, new_feature_obj = cur_replacement_tuple
-                setattr(cur_scenario_device, cur_attr_name, new_feature_obj)
+        for cur_scenario_device, cur_replacement_mapping in self.feature_replacement.items():
+            for cur_feature_mapping in cur_replacement_mapping.mappings:
+                setattr(cur_scenario_device, cur_feature_mapping.attr_name, cur_feature_mapping.setup_feature)
 
     def revert_scenario_device_feature_instances(self):
         """
         This method ensures that all initialized feature instances of a scenario are set back to the initial given
         features.
         """
-        for cur_scenario_device, cur_replacement_dict in self.feature_replacement.items():
-            for cur_attr_name, cur_replacement_tuple in cur_replacement_dict.items():
-                old_instantiated_feature_obj, _ = cur_replacement_tuple
-                setattr(cur_scenario_device, cur_attr_name, old_instantiated_feature_obj)
+        for cur_scenario_device, cur_replacement_mapping in self.feature_replacement.items():
+            for cur_feature_mapping in cur_replacement_mapping.mappings:
+                setattr(cur_scenario_device, cur_feature_mapping.attr_name, cur_feature_mapping.scenario_feature)
 
     def update_active_vdevice_device_mappings_in_all_features(self):
         """
@@ -522,28 +562,28 @@ class VariationExecutor(BasicExecutableExecutor):
         scenario-device classes are set correctly.
         """
 
-        for cur_setup_device, feature_dict in self.abs_setup_feature_vdevice_mappings.items():
+        for cur_setup_device, feature_vdevice_mapping in self.abs_setup_feature_vdevice_mappings.items():
             if cur_setup_device not in self._original_active_vdevice_mappings.keys():
-                self._original_active_vdevice_mappings[cur_setup_device] = {}
-            for cur_setup_feature, mapping_dict in feature_dict.items():
+                self._original_active_vdevice_mappings[cur_setup_device] = FeatureVDeviceMapping()
+            for cur_setup_feature in feature_vdevice_mapping.features:
+                vdev_dev_mappings_of_setup_feat = feature_vdevice_mapping.get_mappings_for_feature(cur_setup_feature)
 
-                cur_setup_feature_vdevice = list(mapping_dict.keys())[0]
-                cur_mapped_setup_device = list(mapping_dict.values())[0]
+                cur_setup_feature_vdevice = vdev_dev_mappings_of_setup_feat[0].vdevice
+                cur_mapped_setup_device = vdev_dev_mappings_of_setup_feat[0].device
 
                 # first save old value to revert it later
-                self._original_active_vdevice_mappings[cur_setup_device][cur_setup_feature] = \
-                    cur_setup_feature.active_vdevices
+                self._original_active_vdevice_mappings[cur_setup_device].add(
+                    feature=cur_setup_feature,
+                    mappings=cur_setup_feature.active_vdevices
+                )
                 # now set new value
                 cur_setup_feature.active_vdevices = {cur_setup_feature_vdevice: cur_mapped_setup_device}
 
                 # now also determine the mapping for the scenario-feature (if there exists one)
                 cur_scenario_device = self.get_scenario_device_for(cur_setup_device)
-                cur_scenario_feature = None
-                for cur_replacement_scenario_feature, cur_replacement_setup_feature in \
-                        self.feature_replacement[cur_scenario_device].values():
-                    if cur_replacement_setup_feature == cur_setup_feature:
-                        cur_scenario_feature = cur_replacement_scenario_feature
-                        break
+                cur_scenario_feature = self.feature_replacement[cur_scenario_device].get_replaced_scenario_feature_for(
+                    cur_setup_feature
+                )
                 if cur_scenario_feature is None:
                     # there exists no scenario feature -> we can ignore this
                     pass
@@ -557,10 +597,12 @@ class VariationExecutor(BasicExecutableExecutor):
                         # only if there exists exactly one scenario vdevice with the same name
 
                         if cur_scenario_device not in self._original_active_vdevice_mappings.keys():
-                            self._original_active_vdevice_mappings[cur_scenario_device] = {}
+                            self._original_active_vdevice_mappings[cur_scenario_device] = FeatureVDeviceMapping()
                         # first save old value to revert it later
-                        self._original_active_vdevice_mappings[cur_scenario_device][cur_scenario_feature] = \
-                            cur_scenario_feature.active_vdevices
+                        self._original_active_vdevice_mappings[cur_scenario_device].add(
+                            feature=cur_scenario_feature,
+                            mappings=cur_scenario_feature.active_vdevices
+                        )
                         # now set new value
                         cur_scenario_feature.active_vdevices = \
                             {cur_scenario_feature_vdevice[0]: self.get_scenario_device_for(cur_mapped_setup_device)}
@@ -568,10 +610,14 @@ class VariationExecutor(BasicExecutableExecutor):
     def revert_active_vdevice_device_mappings_in_all_features(self):
         """
         This method ensures that the `active_vdevices` property that was changed with
-        `update_active_vdevice_device_mappings()` will be reverted correctly.
+        `update_active_vdevice_device_mappings_in_all_features()` will be reverted correctly.
         """
-        for _, cur_feature_mapping_dict in self._original_active_vdevice_mappings.items():
-            for cur_feature, cur_original_mapping in cur_feature_mapping_dict.items():
+        for cur_feature_vdevice_mapping in self._original_active_vdevice_mappings.values():
+            for cur_feature in cur_feature_vdevice_mapping.features:
+                cur_original_mapping = {
+                    mapping.vdevice:mapping.device
+                    for mapping in cur_feature_vdevice_mapping.get_mappings_for_feature(cur_feature)
+                }
                 cur_feature.active_vdevices = cur_original_mapping
 
     def exchange_unmapped_vdevice_references(self):
@@ -631,7 +677,7 @@ class VariationExecutor(BasicExecutableExecutor):
                 cur_vdevice, cur_device = cur_feature.active_vdevice_device_mapping
                 if cur_vdevice is not None and cur_device is not None:
                     cur_vdevice_controller = VDeviceController.get_for(cur_vdevice)
-                    cur_vdevice_all_features = cur_vdevice_controller.get_original_instanced_feature_objects()
+                    cur_vdevice_all_features = cur_vdevice_controller.get_all_instantiated_feature_objects()
 
                     cur_device_controller = DeviceController.get_for(cur_device)
                     cur_device_all_features = cur_device_controller.get_all_instantiated_feature_objects()
@@ -679,116 +725,77 @@ class VariationExecutor(BasicExecutableExecutor):
 
     def determine_absolute_scenario_device_connections(self):
         """
-        This method determines the variation absolute connections for this variation and sets them to the internal
-        properties `_abs_variation_*_device_connections`. This will be used to determine the real connection-subtree
+        This method determines the absolute connections for this variation and sets the internal properties
+        `_abs_variation_*_device_connections` with them. This will be used to determine the real connection-subtree
         (that can be used for this variation) by the method `create_all_valid_routings()`.
 
         The method re-executes the algorithm to determine the absolute connections for a scenario/setup (see the method
         :meth:`Collector.determine_absolute_device_connections_for`), but it considers the real applied vDevice and
         their feature restrictions too.
         """
-        abs_var_scenario_device_cnns = {}
-
         # first determine all relevant absolute connection depending on the current scenario
-        for cur_scenario_device, _ in self.base_device_mapping.items():
-            cur_scenario_device_abs_cnns = \
-                DeviceController.get_for(cur_scenario_device).get_all_absolute_connections()
-            for _, cur_cnn_list in cur_scenario_device_abs_cnns.items():
-                for cur_cnn in cur_cnn_list:
-                    if cur_scenario_device not in abs_var_scenario_device_cnns.keys():
-                        abs_var_scenario_device_cnns[cur_scenario_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] = []
-
-                    abs_var_scenario_device_cnns[cur_scenario_device][cur_to_device].append(cur_cnn)
+        abs_var_scenario_device_cnns = self.cur_scenario_controller.get_all_abs_connections()
 
         # now iterate over every feature, that is used by the scenario and determine the class-based feature connections
         # of the mapped scenario feature (and its vDevice)
-        for cur_setup_device, feature_dict in self.abs_setup_feature_vdevice_mappings.items():
+        for cur_setup_device, feature_vdev_mapping in self.abs_setup_feature_vdevice_mappings.items():
             cur_scenario_device = self.get_scenario_device_for(cur_setup_device)
-            for cur_setup_feature, mapping_dict in feature_dict.items():
-                feature_replacement = {
-                    cur_tuple[1]: cur_tuple[0] for _, cur_tuple in self.feature_replacement[cur_scenario_device].items()
-                }
-                cur_scenario_feature: Feature = feature_replacement[cur_setup_feature]
-                cur_setup_feature_vdevice = list(mapping_dict.keys())[0]
-                cur_mapped_setup_device = list(mapping_dict.values())[0]
+            for cur_setup_feature, vdev_mappings_of_setup_feature in feature_vdev_mapping.items():
+                cur_scenario_feature: Feature = (
+                    self.feature_replacement[cur_scenario_device].get_replaced_scenario_feature_for(
+                        setup_feature=cur_setup_feature)
+                )
 
-                if cur_mapped_setup_device not in self.base_device_mapping.values():
+                if vdev_mappings_of_setup_feature[0].device not in self.base_device_mapping.values():
                     raise NotApplicableVariationException(
-                        f'the mapped setup device `{cur_mapped_setup_device.__qualname__}` which is mapped to the '
-                        f'VDevice `{cur_setup_feature_vdevice.__qualname__}` is no part of this variation')
+                        f'the mapped setup device `{vdev_mappings_of_setup_feature[0].device.__qualname__}` which is '
+                        f'mapped to the VDevice `{vdev_mappings_of_setup_feature[0].vdevice.__qualname__}` is no part '
+                        f'of this variation')
 
-                cur_mapped_scenario_device = self.get_scenario_device_for(cur_mapped_setup_device)
+                cur_mapped_scenario_device = self.get_scenario_device_for(vdev_mappings_of_setup_feature[0].device)
 
                 # get relevant class based connections for the current feature on setup level (this is really be used
                 # here)
-                feature_cnns = \
-                    FeatureController.get_for(
-                        cur_setup_feature.__class__).get_abs_class_based_for_vdevice()[cur_setup_feature_vdevice]
+                feat_cnn = FeatureController.get_for(cur_setup_feature.__class__)\
+                    .get_abs_class_based_for_vdevice()[vdev_mappings_of_setup_feature[0].vdevice]
                 # connection that are relevant for this feature
-                relevant_cnns = abs_var_scenario_device_cnns[cur_scenario_device][cur_mapped_scenario_device]
-
-                relevant_device_cnn = None
+                relevant_cnns = [
+                    cnn for cnn in abs_var_scenario_device_cnns
+                    if (cnn.has_connection_from_to(cur_scenario_device, end_device=cur_mapped_scenario_device)
+                        and max(single_feat_cnn.contained_in(cnn, ignore_metadata=True)
+                                for single_feat_cnn in feat_cnn.get_singles())
+                        )
+                ]
 
                 if len(relevant_cnns) > 1:
-                    # we have parallel possibilities -> determine the selected one (only one is allowed to fit)
-                    for cur_relevant_cnn in relevant_cnns:
-                        for cur_relevant_single_cnn in cur_relevant_cnn.get_singles():
-                            for cur_feature_cnn in feature_cnns:
-                                for cur_feature_single_cnn in cur_feature_cnn.get_singles():
-                                    if cur_feature_single_cnn.contained_in(cur_relevant_single_cnn):
-                                        if relevant_device_cnn is not None:
-                                            raise UnclearAssignableFeatureConnectionError(
-                                                f"the devices {cur_scenario_device.__name__} and "
-                                                f"{cur_mapped_scenario_device.__name__} have multiple parallel "
-                                                f"connections - the device `{cur_scenario_device.__name__}` uses a "
-                                                f"feature `{cur_scenario_feature.__class__.__name__}` that matches "
-                                                f"with the device `{cur_mapped_scenario_device.__name__}`, but it is "
-                                                f"not clear which of the parallel connection could be used"
-                                            )
-                                        relevant_device_cnn = cur_relevant_cnn
-                elif len(relevant_cnns) == 1:
-                    relevant_device_cnn = relevant_cnns[0]
-                if relevant_device_cnn is None:
+                    raise UnclearAssignableFeatureConnectionError(
+                        f"the devices {cur_scenario_device.__name__} and {cur_mapped_scenario_device.__name__} have "
+                        f"multiple parallel connections - the device `{cur_scenario_device.__name__}` uses a feature "
+                        f"`{cur_scenario_feature.__class__.__name__}` that matches with the device "
+                        f"`{cur_mapped_scenario_device.__name__}`, but it is not clear which of the parallel "
+                        f"connection could be used")
+
+                if len(relevant_cnns) == 0:
                     # todo this does not map here
                     raise ValueError("can not find matching connection on scenario level")
 
+                relevant_device_cnn = relevant_cnns[0]
+
                 # now cleanup the scenario-device connection `relevant_device_cnn` according to the class-based feature
                 # connection
-                new_cleaned_singles = []
-                for cur_old_cnn_single in relevant_device_cnn.get_singles():
-                    for cur_feature_cnn in feature_cnns:
-                        if cur_feature_cnn.contained_in(cur_old_cnn_single, ignore_metadata=True):
-                            new_cleaned_singles.append(cur_old_cnn_single)
-
-                new_cnn_to_replace = Connection.based_on(*new_cleaned_singles)
-                new_cnn_to_replace.set_metadata_for_all_subitems(new_cleaned_singles[0].metadata)
-
-                abs_var_scenario_device_cnns[cur_scenario_device][cur_mapped_scenario_device].remove(
-                    relevant_device_cnn)
-                abs_var_scenario_device_cnns[cur_scenario_device][cur_mapped_scenario_device].append(new_cnn_to_replace)
-
-                # also search the connection in the other direction
-                other_dir_relevant_device_cnn = None
-                for cur_cnn in abs_var_scenario_device_cnns[cur_mapped_scenario_device][cur_scenario_device]:
-                    if cur_cnn.equal_with(relevant_device_cnn):
-                        other_dir_relevant_device_cnn = cur_cnn
-                        break
-                # and also replace it
-                abs_var_scenario_device_cnns[cur_mapped_scenario_device][cur_scenario_device].remove(
-                    other_dir_relevant_device_cnn)
-                abs_var_scenario_device_cnns[cur_mapped_scenario_device][cur_scenario_device].append(new_cnn_to_replace)
+                new_cnn_to_replace = Connection.based_on(OrConnectionRelation(*[
+                    cur_old_cnn_single for cur_old_cnn_single in relevant_device_cnn.get_singles()
+                    if feat_cnn.contained_in(cur_old_cnn_single, ignore_metadata=True)
+                ]))
+                new_cnn_to_replace.set_metadata_for_all_subitems(relevant_device_cnn.metadata)
+
+                abs_var_scenario_device_cnns.remove(relevant_device_cnn)
+                abs_var_scenario_device_cnns.append(new_cnn_to_replace)
+
+                # we do not need to check other direction because `has_connection_from_to()` returns both possibilities
 
         # set the determined values in variation object
-        self._abs_variation_scenario_device_connections = []
-        for _, from_device_dict in abs_var_scenario_device_cnns.items():
-            for _, cur_cnn_list in from_device_dict.items():
-                for cur_cnn in cur_cnn_list:
-                    self._abs_variation_scenario_device_connections.append(cur_cnn)
+        self._abs_variation_scenario_device_connections = abs_var_scenario_device_cnns
 
     def create_all_valid_routings(self):
         """
@@ -828,16 +835,18 @@ class VariationExecutor(BasicExecutableExecutor):
                 if virtual_routing_cnns[cur_cnn] is None:
                     virtual_routing_cnns[cur_cnn] = Connection.based_on(virtual_cnn)
                 else:
-                    virtual_routing_cnns[cur_cnn] = Connection.based_on(virtual_routing_cnns[cur_cnn], virtual_cnn)
+                    virtual_routing_cnns[cur_cnn] = Connection.based_on(
+                        OrConnectionRelation(virtual_routing_cnns[cur_cnn], virtual_cnn))
                 virtual_routing_cnns[cur_cnn].set_metadata_for_all_subitems(virtual_cnn.metadata)
 
         self._abs_variation_connections = []
         for cur_cnn in self._abs_variation_scenario_device_connections:
             cur_virtual_cnn = virtual_routing_cnns[cur_cnn]
             new_intersection = cur_cnn.intersection_with(cur_virtual_cnn)
-            new_intersection.set_metadata_for_all_subitems(None)
-            # always set the metadata for setup devices
-            new_intersection.set_metadata_for_all_subitems(cur_virtual_cnn.metadata)
+            if new_intersection:
+                new_intersection.set_metadata_for_all_subitems(None)
+                # always set the metadata for setup devices
+                new_intersection.set_metadata_for_all_subitems(cur_virtual_cnn.metadata)
             self._abs_variation_connections.append(new_intersection)
 
     def set_conn_dependent_methods(self):
@@ -873,11 +882,15 @@ class VariationExecutor(BasicExecutableExecutor):
                     relevant_abs_conn = []
                     for cur_cnn in self._abs_variation_connections:
                         if cur_cnn.has_connection_from_to(start_device=setup_device, end_device=mapped_setup_device):
-                            relevant_abs_conn.append(cur_cnn)
+                            # add the children
+                            relevant_abs_conn.extend(
+                                cur_cnn.based_on_elements.connections if cur_cnn.__class__ == Connection else [cur_cnn]
+                            )
+
                     if len(relevant_abs_conn) is None:
                         raise RuntimeError(f"detect empty absolute connection between device `{setup_device.__name__}` "
                                            f"and device `{mapped_setup_device.__name__}`")
-                    absolute_feature_method_var_cnn = Connection.based_on(*relevant_abs_conn)
+                    absolute_feature_method_var_cnn = Connection.based_on(OrConnectionRelation(*relevant_abs_conn))
                     cur_method_variation = cur_setup_feature_controller.get_method_variation(
                         of_method_name=cur_method_name, for_vdevice=mapped_vdevice,
                         with_connection=absolute_feature_method_var_cnn)