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

_balder/executor/variation_executor.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
-import itertools
-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
@@ -16,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
 
@@ -23,7 +24,6 @@ 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
@@ -50,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
@@ -67,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
@@ -138,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
@@ -175,7 +171,7 @@ class VariationExecutor(BasicExecutableExecutor):
             self.exchange_unmapped_vdevice_references()
             self.update_vdevice_referenced_feature_instances()
             self.set_conn_dependent_methods()
-            self.resolve_possible_parametrization()
+            self.resolve_and_exchange_unresolved_parametrization()
 
     def _body_execution(self, show_discarded):
         if show_discarded and not self.can_be_applied():
@@ -183,13 +179,10 @@ class VariationExecutor(BasicExecutableExecutor):
             return
 
         for cur_testcase_executor in self.get_testcase_executors():
-            if cur_testcase_executor.has_runnable_tests():
-
+            if (cur_testcase_executor.has_runnable_tests()
+                    or cur_testcase_executor.has_skipped_tests()
+                    or cur_testcase_executor.has_covered_by_tests()):
                 cur_testcase_executor.execute()
-            elif cur_testcase_executor.prev_mark == PreviousExecutorMark.SKIP:
-                cur_testcase_executor.set_result_for_whole_branch(ResultState.SKIP)
-            elif cur_testcase_executor.prev_mark == PreviousExecutorMark.COVERED_BY:
-                cur_testcase_executor.set_result_for_whole_branch(ResultState.COVERED_BY)
             else:
                 cur_testcase_executor.set_result_for_whole_branch(ResultState.NOT_RUN)
 
@@ -230,26 +223,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
@@ -258,7 +247,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
@@ -343,16 +332,9 @@ class VariationExecutor(BasicExecutableExecutor):
             return super().testsummary()
         return ResultSummary()
 
-    def get_testcase_executors(self) -> List[TestcaseExecutor]:
+    def get_testcase_executors(self) -> List[TestcaseExecutor | UnresolvedParametrizedTestcaseExecutor]:
         """returns all sub testcase executors that belongs to this variation-executor"""
-        result = []
-        for cur_executor in self._testcase_executors:
-            if (isinstance(cur_executor, UnresolvedParametrizedTestcaseExecutor) and
-                    cur_executor.parametrization_has_been_resolved):
-                result += cur_executor.get_testcase_executors()
-            else:
-                result.append(cur_executor)
-        return result
+        return self._testcase_executors.copy()
 
     def add_testcase_executor(self, testcase_executor: TestcaseExecutor | UnresolvedParametrizedTestcaseExecutor):
         """
@@ -388,15 +370,17 @@ 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 = {scenario_dev: {} for scenario_dev in self.base_device_mapping.keys()}
-        abs_setup_vdevice_mappings = {setup_dev: {} for setup_dev in self.base_device_mapping.values()}
+        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()
 
-            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_scenario_feature_obj in cur_scenario_device_orig_features.items():
+            for cur_attr_name, cur_scenario_feature_obj in \
+                    DeviceController.get_for(cur_scenario_device).get_all_instantiated_feature_objects().items():
                 active_scenario_vdevice, mapped_scenario_device = cur_scenario_feature_obj.active_vdevice_device_mapping
 
                 cur_setup_feature_objs = self._get_matching_setup_features_for(
@@ -410,13 +394,14 @@ class VariationExecutor(BasicExecutableExecutor):
                         f'`{cur_scenario_device.__name__}`) in setup device `{cur_setup_device.__name__}`')
                 cur_setup_feature_obj = cur_setup_feature_objs[0]
 
+                all_abs_inner_vdevs_of_setup = \
+                    FeatureController.get_for(cur_setup_feature_obj.__class__).get_abs_inner_vdevice_classes()
+                used_setup_vdevice, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
+
                 if mapped_scenario_device is None:
                     # we have exactly one matching candidate, but also no vDevice mapping
                     # check if the matching candidate has a vDevice mapping
-                    _, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
-                    cleanup_feature_controller = FeatureController.get_for(cur_setup_feature_obj.__class__)
-                    if mapped_setup_device is None \
-                            and len(cleanup_feature_controller.get_abs_inner_vdevice_classes()) > 0:
+                    if mapped_setup_device is None and len(all_abs_inner_vdevs_of_setup) > 0:
                         # there is no vDevice mapping on scenario and no vDevice mapping on setup level, but the
                         # feature defined vDevices -> NOT APPLICABLE
                         logger.warning(
@@ -430,42 +415,38 @@ class VariationExecutor(BasicExecutableExecutor):
                             f'`{cur_scenario_feature_obj.__class__.__name__}` (used by scenario device '
                             f'`{cur_scenario_device.__name__}`) in setup device `{cur_setup_device.__name__}`')
 
-                all_assigned_setup_features.append(cur_setup_feature_obj)
-                if cur_attr_name not in feature_replacement[cur_scenario_device].keys():
-                    cleanup_feature_controller = FeatureController.get_for(cur_setup_feature_obj.__class__)
-
-                    used_setup_vdevice, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
+                if cur_attr_name not in feature_replacement[cur_scenario_device].attr_names:
 
                     # if there is a vDevice mapping on scenario level, but not on setup level, so update the
                     # VDevice-Device-Mapping there
                     if mapped_scenario_device is not None and mapped_setup_device is None:
                         # search the equivalent vDevice on setup level and use this one (we had not to check it,
                         # because check was already done in collector-stage)
-                        setup_vdevices = [cur_vdevice for cur_vdevice
-                                          in cleanup_feature_controller.get_abs_inner_vdevice_classes()
+                        setup_vdevices = [cur_vdevice for cur_vdevice in all_abs_inner_vdevs_of_setup
                                           if cur_vdevice.__name__ == active_scenario_vdevice.__name__]
                         used_setup_vdevice = setup_vdevices[0]
                         # set the mapping
-                        abs_setup_vdevice_mappings[cur_setup_device][cur_setup_feature_obj] = {
-                            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][cur_setup_feature_obj] = {
-                            used_setup_vdevice: mapped_setup_device}
-
-                    feature_replacement[cur_scenario_device][cur_attr_name] = \
-                        (cur_scenario_feature_obj, cur_setup_feature_obj)
-            # also add all setup features that are not assigned as autonomous features
-            for cur_setup_feature in cur_setup_features.values():
-                if cur_setup_feature not in all_assigned_setup_features:
-                    # determine free name
-                    idx = 0
-                    autonomous_name = None
-                    while autonomous_name is None or autonomous_name in feature_replacement[cur_scenario_device].keys():
-                        autonomous_name = f"_autonomous_feat_{idx}"
-                        idx += 1
-                    feature_replacement[cur_scenario_device][autonomous_name] = (None, cur_setup_feature)
+                        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].add_remaining_setup_features_as_autonomous(cur_setup_device)
 
         # set the result to internal properties
         self._feature_replacement = feature_replacement
@@ -531,20 +512,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):
         """
@@ -552,28 +531,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
@@ -587,10 +566,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)}
@@ -598,10 +579,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):
@@ -661,7 +646,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()
@@ -722,64 +707,54 @@ class VariationExecutor(BasicExecutableExecutor):
 
         # 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_cnn = \
-                    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 = [
                     cnn for cnn in abs_var_scenario_device_cnns
-                    if cnn.has_connection_from_to(cur_scenario_device, end_device=cur_mapped_scenario_device)
+                    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())
+                        )
                 ]
 
-                relevant_device_cnn = None
-
                 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, cur_feature_single_cnn in (
-                                itertools.product(cur_relevant_cnn.get_singles(), feature_cnn.get_singles())):
-                            if not cur_feature_single_cnn.contained_in(cur_relevant_single_cnn, ignore_metadata=True):
-                                continue
-                            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 connections - the "
-                                    f"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 "
-                                    f"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_cnn_to_replace = Connection.based_on(OrConnectionRelation(*[
                     cur_old_cnn_single for cur_old_cnn_single in relevant_device_cnn.get_singles()
-                    if feature_cnn.contained_in(cur_old_cnn_single, ignore_metadata=True)
+                    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)
 
@@ -896,8 +871,12 @@ class VariationExecutor(BasicExecutableExecutor):
 
                 cur_setup_feature_controller.set_active_method_variation(method_selection=method_var_selection)
 
-    def resolve_possible_parametrization(self):
+    def resolve_and_exchange_unresolved_parametrization(self):
         """resolves the parametrization if there are any :class:`UnresolvedParametrizedTestcaseExecutor` in the tree"""
+        replaced_executors = []
         for cur_child in self._testcase_executors:
             if isinstance(cur_child, UnresolvedParametrizedTestcaseExecutor):
-                cur_child.resolve_dynamic_parametrization()
+                replaced_executors.extend(cur_child.get_resolved_parametrized_testcase_executors())
+            else:
+                replaced_executors.append(cur_child)
+        self._testcase_executors = replaced_executors

_balder/feature.py

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

_balder/feature_replacement_mapping.py

@@ -0,0 +1,107 @@
+from typing import Union, Type
+import dataclasses
+from .device import Device
+from .feature import Feature
+from .controllers import DeviceController
+
+
+class FeatureReplacementMapping:
+    """
+    helper object that stores mappings between scenario and setup features - is used in :class:`VariationExecutor`
+    """
+
+    @dataclasses.dataclass
+    class FeatureMapping:
+        """
+        stores a single mapping
+        """
+        #: the feature attribute name in scenario device
+        attr_name: str
+        #: the scenario feature instance or None if the current variation does not use this setup feature in scenario
+        scenario_feature: Union[Feature, None]
+        #: the setup feature that is used for the scenario feature
+        setup_feature: Feature
+
+    def __init__(self):
+        self._mappings: list[FeatureReplacementMapping.FeatureMapping] = []
+
+    @property
+    def mappings(self) -> list[FeatureMapping]:
+        """
+        returns all existing mappings
+        """
+        return list(self._mappings)
+
+    @property
+    def attr_names(self) -> list[str]:
+        """
+        returns all used attribute names
+        """
+        return [mapping.attr_name for mapping in self._mappings]
+
+    @property
+    def all_scenario_features(self) -> list[Feature]:
+        """
+        returns all scenario features
+        """
+        return [mapping.scenario_feature for mapping in self._mappings]
+
+    @property
+    def all_setup_features(self) -> list[Feature]:
+        """
+        returns all setup features
+        """
+        return [mapping.setup_feature for mapping in self._mappings]
+
+    def add(self, attr_name: str, scenario_feature: Union[Feature, None], setup_feature: Feature):
+        """
+        adds a new mapping
+
+        :param attr_name: the feature attribute name in scenario device
+        :param scenario_feature: the scenario feature instance or None if the current variation does not use this setup
+                                 feature in scenario
+        :param setup_feature: the setup feature that is used for the scenario feature
+        """
+        if attr_name in self.attr_names:
+            raise KeyError(f'entry for property name `{attr_name}` already exist - can not define it multiple times')
+        self._mappings.append(FeatureReplacementMapping.FeatureMapping(attr_name, scenario_feature, setup_feature))
+
+    def get_features_for_attr_name(self, attr_name: str) -> tuple[Feature, Feature]:
+        """
+        returns the scenario and its mapped setup feature for a specific attribute name used in the scenario device
+        """
+        for mapping in self._mappings:
+            if mapping.attr_name == attr_name:
+                return mapping.scenario_feature, mapping.setup_feature
+        raise KeyError(f'entry for property name `{attr_name}` does not exist')
+
+    def get_replaced_scenario_feature_for(self, setup_feature: Feature) -> Union[Feature, None]:
+        """
+        returns the mapped scenario feature for a given setup feature
+        """
+        for mapping in self._mappings:
+            if mapping.setup_feature == setup_feature:
+                return mapping.scenario_feature
+        raise KeyError(f'cannot find setup feature for {setup_feature}')
+
+    def add_remaining_setup_features_as_autonomous(self, cur_setup_device: Type[Device]):
+        """
+        Adds all features that were not added as autonomous features.
+        """
+        cur_setup_features = DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
+
+        # also add all setup features that are not assigned as autonomous features
+        for cur_setup_feature in cur_setup_features.values():
+            if cur_setup_feature not in self.all_setup_features:
+                # determine free name
+                idx = 0
+                autonomous_name = None
+                while (autonomous_name is None
+                       or autonomous_name in self.attr_names):
+                    autonomous_name = f"_autonomous_feat_{idx}"
+                    idx += 1
+                self.add(
+                    attr_name=autonomous_name,
+                    scenario_feature=None,
+                    setup_feature=cur_setup_feature
+                )