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

_balder/controllers/device_controller.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import copy
 from typing import Dict, List, Type, Union, TYPE_CHECKING
 
-import sys
 import logging
 import inspect
 from abc import ABC
@@ -13,7 +12,7 @@ from _balder.vdevice import VDevice
 from _balder.scenario import Scenario
 from _balder.controllers.base_device_controller import BaseDeviceController
 from _balder.controllers.feature_controller import FeatureController
-from _balder.exceptions import DeviceScopeError, DeviceResolvingException, InnerFeatureResolvingError, \
+from _balder.exceptions import DeviceResolvingException, InnerFeatureResolvingError, \
     FeatureOverwritingError, MultiInheritanceError
 if TYPE_CHECKING:
     from _balder.connection import Connection
@@ -108,6 +107,7 @@ class DeviceController(BaseDeviceController, ABC):
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
 
     def __get_outer_class_controller(self) -> Union[ScenarioController, SetupController]:
+        # pylint: disable-next=import-outside-toplevel
         from _balder.controllers.normal_scenario_setup_controller import NormalScenarioSetupController
 
         outer_class = self.get_outer_class()
@@ -307,25 +307,7 @@ class DeviceController(BaseDeviceController, ABC):
         This method delivers the outer class of the related device. This has to be a :class:`Setup` or a
         :class:`Scenario`.
         """
-
-        if self.related_cls.__qualname__.count('.') == 0:
-            raise DeviceScopeError("the current device class is no inner class")
-
-        if self.related_cls.__qualname__.count('.') > 1:
-            raise DeviceScopeError("the current device class is no direct inner class (deeper than one)")
-
-        outer_class_name, _ = self.related_cls.__qualname__.split('.')
-
-        outer_class = [cur_class for cur_name, cur_class in inspect.getmembers(
-            inspect.getmodule(self.related_cls)) if cur_name == outer_class_name][0]
-
-        all_inner_classes = [cur_inner_class for _, cur_inner_class in inspect.getmembers(outer_class, inspect.isclass)]
-        if self.related_cls in all_inner_classes:
-            if not issubclass(outer_class, Setup) and not issubclass(outer_class, Scenario):
-                raise TypeError(
-                    f"the outer class is of the type `{outer_class.__name__}` - this is not allowed")
-            return outer_class
-        raise RuntimeError(f"can not find the outer class of this given device `{self.related_cls.__qualname__}`")
+        return getattr(self.related_cls, '_outer_balder_class', None)
 
     def resolve_connection_device_strings(self):
         """
@@ -350,9 +332,8 @@ class DeviceController(BaseDeviceController, ABC):
                     return
 
                 # get outer class of `from_device`
-                outer_cls_name_from_device = cur_conn.from_device.__qualname__.rpartition('.')[0]
-                mod = sys.modules[cur_conn.from_device.__module__]
-                parent_cls_from_device = getattr(mod, outer_cls_name_from_device)
+                from_device_controller = DeviceController.get_for(cur_conn.from_device)
+                parent_cls_from_device = from_device_controller.get_outer_class()
 
                 all_inner_classes_of_outer = dict(inspect.getmembers(parent_cls_from_device, inspect.isclass))
                 if cur_conn.to_device in all_inner_classes_of_outer.keys():

_balder/controllers/feature_controller.py

@@ -395,8 +395,8 @@ class FeatureController(Controller):
             if not issubclass(cur_class, VDevice):
                 # filter all classes and make sure that only the child classes of :class:`VDevice` remain
                 continue
-            outer_class_name, _ = cur_class.__qualname__.split('.')[-2:]
-            if outer_class_name != self.related_cls.__name__:
+
+            if VDeviceController.get_for(cur_class).get_outer_class() != self.related_cls:
                 # filter all classes that do not match the setup name in __qualname__
                 continue
             # otherwise, add this candidate

_balder/controllers/normal_scenario_setup_controller.py

@@ -72,8 +72,7 @@ class NormalScenarioSetupController(Controller, ABC):
             if not issubclass(cur_class, Device):
                 # filter all classes and make sure that only the child classes of :meth:`Device` remain
                 continue
-            outer_class_name, _ = cur_class.__qualname__.split('.')
-            if outer_class_name != self.related_cls.__name__:
+            if DeviceController.get_for(cur_class).get_outer_class() != self.related_cls:
                 # filter all classes that do not match the setup name in __qualname__
                 continue
             # otherwise, add this candidate

_balder/controllers/scenario_controller.py

@@ -14,6 +14,7 @@ from _balder.controllers.normal_scenario_setup_controller import NormalScenarioS
 from _balder.parametrization import FeatureAccessSelector, Parameter
 from _balder.exceptions import UnclearAssignableFeatureConnectionError, ConnectionIntersectionError, \
     MultiInheritanceError
+from _balder.utils.functions import get_scenario_inheritance_list_of
 
 logger = logging.getLogger(__file__)
 
@@ -36,6 +37,9 @@ class ScenarioController(NormalScenarioSetupController):
         # describes if the current controller is for setups or for scenarios (has to be set in child controller)
         self._related_type = Scenario
 
+        # holds covered-by configuration
+        self._covered_by = {}
+
         # this helps to make this constructor only possible inside the controller object
         if _priv_instantiate_key != ScenarioController.__priv_instantiate_key:
             raise RuntimeError('it is not allowed to instantiate a controller manually -> use the static method '
@@ -126,6 +130,73 @@ class ScenarioController(NormalScenarioSetupController):
             ordered_dict[cur_arg] = params[cur_arg]
         return ordered_dict
 
+    def register_covered_by_for(self, meth: Union[str, None], covered_by: Union[Scenario, Callable, None]) -> None:
+        """
+        This method registers a covered-by statement for this Scenario. If `meth` is provided, the statement is for the
+        specific test method of the scenario, otherwise it is for the whole setup. The item provided in `covered_by`
+        describes the test object that covers this scenario (method).
+
+        :param meth: if provided this attribute describes the test method that should be registered, otherwise the whole
+                     scenario will be registered
+        :param covered_by: describes the test object that covers this scenario (method)
+        """
+        if not (meth is None or isinstance(meth, str)):
+            raise TypeError('meth needs to be None or a string')
+        if meth is not None:
+            if not meth.startswith('test_'):
+                raise TypeError(
+                    f"the use of the `@covered_by` decorator is only allowed for `Scenario` objects and test methods "
+                    f"of `Scenario` objects - the method `{self.related_cls.__name__}.{meth}` does not start with "
+                    f"`test_` and is not a valid test method")
+            if not hasattr(self.related_cls, meth):
+                raise ValueError(
+                    f"the provided test method `{meth}` does not exist in scenario `{self.related_cls.__name__}`"
+                )
+
+        if meth not in self._covered_by.keys():
+            self._covered_by[meth] = []
+        if covered_by is None:
+            # reset it
+            # todo what if there are more than one decorator in one class
+            del self._covered_by[meth]
+        else:
+            self._covered_by[meth].append(covered_by)
+
+    def get_raw_covered_by_dict(self) -> Dict[Union[str, None], List[Union[Scenario, Callable]]]:
+        """
+        :return: returns the internal covered-by dictionary
+        """
+        return self._covered_by.copy()
+
+    def get_abs_covered_by_dict(self) -> Dict[Union[str, None], List[Union[Scenario, Callable]]]:
+        """
+        This method resolves the covered-by statements over all inheritance levels. It automatically
+        cleans up every inheritance of the covered_by decorators for every parent class of this scenario.
+        """
+        parent_classes = [p for p in self.related_cls.__bases__ if issubclass(p, Scenario) and p != Scenario]
+        if len(parent_classes) > 1:
+            raise MultiInheritanceError(
+                f'can not resolve classes for `{self.related_cls}` because there are more than one Scenario based '
+                f'parent classes'
+            )
+        # no more parent classes -> raw is absolute
+        if len(parent_classes) == 0:
+            return self.get_raw_covered_by_dict()
+        parent_controller = self.__class__.get_for(parent_classes[0])
+        self_raw_covered_by_dict = self.get_raw_covered_by_dict()
+
+        #: first fill result with data from parent controller
+        result = {
+            k if k is None else getattr(self.related_cls, k.__name__): v
+            for k, v in parent_controller.get_abs_covered_by_dict().items()
+        }
+        for cur_callable, cur_coveredby in self_raw_covered_by_dict.items():
+            if cur_callable in result.keys():
+                result[cur_callable].extend(cur_coveredby)
+            else:
+                result[cur_callable] = cur_coveredby
+        return result
+
     def check_for_parameter_loop_in_dynamic_parametrization(self, cur_fn: Callable):
         """
         This method checks for a parameter loop in all dynamic parametrization for a specific test method. If it detects
@@ -196,6 +267,56 @@ class ScenarioController(NormalScenarioSetupController):
 
         return all_relevant_func
 
+    def get_ignore_test_methods(self) -> List[callable]:
+        """
+        This method returns a list of all methods that have the IGNORE marker. It automatically resolves marker that
+        were provided on parent class scenarios.
+        """
+        result = []
+        next_parent_class = get_scenario_inheritance_list_of(self.related_cls)[1]
+        if next_parent_class != Scenario:
+            next_parent_class_controller = ScenarioController.get_for(next_parent_class)
+            next_parent_ignore_meths = next_parent_class_controller.get_ignore_test_methods()
+            result.extend(next_parent_ignore_meths)
+        for cur_ignore_meth_as_str in self.related_cls.IGNORE:
+            cur_ignore_meth = getattr(self.related_cls, cur_ignore_meth_as_str)
+            result.append(cur_ignore_meth)
+        return list(set(result))
+
+    def get_skip_test_methods(self) -> List[callable]:
+        """
+        This method returns a list of all methods that have the SKIP marker. It automatically resolves marker that were
+        provided on parent class scenarios.
+        """
+        result = []
+        next_parent_class = get_scenario_inheritance_list_of(self.related_cls)[1]
+        next_parent_ignore_meths = []
+
+        if next_parent_class != Scenario:
+            next_parent_class_controller = ScenarioController.get_for(next_parent_class)
+            next_parent_ignore_meths = next_parent_class_controller.get_ignore_test_methods()
+            next_parent_skip_meths = next_parent_class_controller.get_skip_test_methods()
+            result.extend(next_parent_skip_meths)
+
+        for cur_skip_meth_as_str in self.related_cls.SKIP:
+            cur_skip_meth = getattr(self.related_cls, cur_skip_meth_as_str)
+            if cur_skip_meth in next_parent_ignore_meths:
+                raise ValueError(f'found skip method `{cur_skip_meth}` defined in `{self.related_cls}.SKIP`, but was '
+                                 f'already added to IGNORE in parent class')
+            result.append(cur_skip_meth)
+
+        return list(set(result))
+
+    def get_run_test_methods(self) -> List[callable]:
+        """
+        This method returns a list of all methods that should run in this scenario. It automatically resolves
+        SKIP/IGNORE marker that were provided on parent class scenarios.
+        """
+        result = (set(self.get_all_test_methods())
+                  - set(self.get_skip_test_methods())
+                  - set(self.get_ignore_test_methods()))
+        return list(result)
+
     def validate_feature_clearance_for_parallel_connections(self):
         """
         This method validates for every active class-based feature (only the ones that have an active VDevice<->Device

_balder/controllers/vdevice_controller.py

@@ -2,11 +2,10 @@ from __future__ import annotations
 from typing import Type, Dict, Union
 
 import logging
-import inspect
 from _balder.vdevice import VDevice
 from _balder.feature import Feature
 from _balder.controllers.base_device_controller import BaseDeviceController
-from _balder.exceptions import DeviceScopeError, VDeviceResolvingError
+from _balder.exceptions import VDeviceResolvingError
 
 logger = logging.getLogger(__file__)
 
@@ -69,27 +68,7 @@ class VDeviceController(BaseDeviceController):
         """
         This method delivers the outer class of this device. In Balder, this has to be a :class:`Feature`.
         """
-
-        if self.related_cls.__qualname__.count('.') == 0:
-            raise DeviceScopeError("the current device class is no inner class")
-        all_splits = self.related_cls.__qualname__.split('.')
-
-        outer_class = [cur_class for cur_name, cur_class in inspect.getmembers(
-            inspect.getmodule(self.related_cls), inspect.isclass) if cur_name == all_splits[0]][0]
-        # only get the next outer class (not higher)
-        for cur_class_name in all_splits[1:-1]:
-            outer_class = getattr(outer_class, cur_class_name)
-        # instantiate it to get the real type (not the decorator class of `@for_vdevice`)
-        #  we can instantiate it, because we do nothing in it
-        outer_class = outer_class().__class__
-
-        all_inner_classes = [cur_inner_class for _, cur_inner_class in inspect.getmembers(outer_class, inspect.isclass)]
-        if self.related_cls in all_inner_classes:
-            if not issubclass(outer_class, Feature):
-                raise TypeError(f"the found outer class is of type `{outer_class.__name__}` - this is a type which is "
-                                f"not allowed (outer class has to be a `Feature` class)")
-            return outer_class
-        raise RuntimeError(f"can not find the outer class of this vDevice `{self.related_cls.__qualname__}`")
+        return getattr(self.related_cls, '_outer_balder_class', None)
 
     def get_next_parent_vdevice(self) -> Union[Type[VDevice], None]:
         """

_balder/decorator_connect.py

@@ -69,10 +69,10 @@ def connect(
             nonlocal self_node_name
             nonlocal dest_node_name
 
-            this_outer_class_name, _ = decorated_cls.__qualname__.split('.')
+            this_outer_ref = decorated_cls.__qualname__.split('.')[:-1]
             if not isinstance(with_device, str):
-                other_outer_class_name, _ = with_device.__qualname__.split('.')
-                if this_outer_class_name != other_outer_class_name:
+                other_outer_ref = with_device.__qualname__.split('.')[:-1]
+                if this_outer_ref != other_outer_ref:
                     raise ValueError(
                         f"the given device is not mentioned in this setup/scenario - please create a new "
                         f"direct inner device class, it can be inherited from `{with_device.__qualname__}`")

_balder/decorator_covered_by.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 from typing import Type, Union
 
 import inspect
+
+from _balder.controllers import ScenarioController
 from _balder.scenario import Scenario
-from _balder.utils import get_class_that_defines_method
 
 
-def covered_by(item: Union[Type[Scenario], callable, None]):
+def covered_by(item: Union[Type[Scenario], str, callable, None]):
     """
     This decorator defines that there exists another Scenario class or test method item that has a similar
     implementation like the decorated :class:`Scenario` class or the decorated test method.
@@ -16,14 +17,15 @@ def covered_by(item: Union[Type[Scenario], callable, None]):
 
     if item is None:
         pass
-    elif callable(item) and inspect.isfunction(item) and item.__name__.startswith("test_") and \
-            issubclass(get_class_that_defines_method(item), Scenario):
+    elif isinstance(item, str) and item.startswith("test_"):
         pass
-    elif isinstance(item, type) and issubclass(item, Scenario):
+    elif callable(item) and inspect.isfunction(item) and item.__name__.startswith("test_"):
         pass
+    elif isinstance(item, type) and issubclass(item, Scenario):
+        raise NotImplementedError('The covered-by other scenario classes is not supported yet')
     else:
-        raise TypeError("the given element for `item` must be a `Scenario` (or a subclass thereof) or a test method of "
-                        "a scenario class (has to start with `test_`)")
+        raise TypeError("the given element for `item` must be a test method of a scenario class (has to start with "
+                        "`test_`)")
 
     class CoveredByDecorator:
         """decorator class for `@covered_by` decorator"""
@@ -36,46 +38,36 @@ def covered_by(item: Union[Type[Scenario], callable, None]):
                     raise TypeError(f"The decorator `@covered_by` may only be used for `Scenario` objects or for test "
                                     f"methods of one `Scenario` object. This is not possible for the applied class "
                                     f"`{func.__name__}`.")
-                if not hasattr(func, '_covered_by'):
-                    func._covered_by = {}
-                if func not in func._covered_by.keys():
-                    func._covered_by[func] = []
-                if item is None:
-                    # reset it
-                    func._covered_by[func] = []
-                elif item not in func._covered_by[func]:
-                    func._covered_by[func].append(item)
-            elif inspect.isfunction(func):
+                raise NotImplementedError('The covered-by decoration of other scenario classes is not supported yet')
+                # scenario_controller = ScenarioController.get_for(func)
+                # register for the whole class
+                # scenario_controller.register_covered_by_for(meth=None, covered_by=item)
+            if inspect.isfunction(func):
                 # work will done in `__set_name__`
                 pass
             else:
                 raise TypeError(f"The use of the `@covered_by` decorator is not allowed for the `{str(func)}` element. "
-                                f"You should only use this decorator for `Scenario` elements or test method elements "
-                                f"of a `Scenario` object")
+                                f"You should only use this decorator for test method elements of a `Scenario` object")
 
         def __set_name__(self, owner, name):
             if issubclass(owner, Scenario):
                 if not inspect.isfunction(self.func):
-                    raise TypeError("the use of the `@covered_by` decorator is only allowed for `Scenario` objects and "
-                                    "test methods of `Scenario` objects")
+                    raise TypeError("the use of the `@covered_by` decorator is only allowed for test methods of "
+                                    "`Scenario` objects")
                 if not name.startswith('test_'):
-                    raise TypeError(f"the use of the `@covered_by` decorator is only allowed for `Scenario` objects "
-                                    f"and test methods of `Scenario` objects - the method `{owner.__name__}.{name}` "
-                                    f"does not start with `test_` and is not a valid test method")
-
-                if not hasattr(owner, '_covered_by'):
-                    owner._covered_by = {}
-                if self.func not in owner._covered_by.keys():
-                    owner._covered_by[self.func] = []
-                if item is None:
-                    # reset it
-                    owner._covered_by[self.func] = []
-                elif item not in owner._covered_by[self.func]:
-                    owner._covered_by[self.func].append(item)
+                    raise TypeError(f"the use of the `@covered_by` decorator is only allowed for test methods of "
+                                    f"`Scenario` objects - the method `{owner.__name__}.{name}` does not start with "
+                                    f"`test_` and is not a valid test method")
+                # if item is a string - resolve method
+                cleared_item = item
+                if isinstance(item, str):
+                    cleared_item = getattr(owner, item)
+                scenario_controller = ScenarioController.get_for(owner)
+                scenario_controller.register_covered_by_for(meth=name, covered_by=cleared_item)
             else:
                 raise TypeError(f"The use of the `@covered_by` decorator is not allowed for methods of a "
-                                f"`{owner.__name__}`. You should only use this decorator for `Scenario` objects or "
-                                f"valid test methods of a `Scenario` object")
+                                f"`{owner.__name__}`. You should only use this decorator for valid test methods of a "
+                                f"`Scenario` object")
 
             setattr(owner, name, self.func)
 

_balder/executor/basic_executable_executor.py

@@ -9,7 +9,7 @@ import traceback
 from abc import ABC, abstractmethod
 
 from _balder.executor.basic_executor import BasicExecutor
-from _balder.testresult import ResultState, TestcaseResult
+from _balder.testresult import ResultState
 
 if TYPE_CHECKING:
     from _balder.fixture_execution_level import FixtureExecutionLevel
@@ -73,9 +73,11 @@ class BasicExecutableExecutor(BasicExecutor, ABC):
         """
         if value not in (ResultState.SKIP, ResultState.COVERED_BY, ResultState.NOT_RUN):
             raise ValueError("can not set a state that is not NOT_RUN, SKIP or COVERED_BY for a whole branch")
-        for cur_child_executor in self.all_child_executors:
-            if isinstance(cur_child_executor.body_result, TestcaseResult):
-                cur_child_executor.body_result.set_result(result=value, exception=None)
+        if self.all_child_executors is None:
+            self.body_result.set_result(result=value, exception=None)
+        else:
+            for cur_child_executor in self.all_child_executors:
+                cur_child_executor.set_result_for_whole_branch(value)
 
     @abstractmethod
     def cleanup_empty_executor_branches(self, consider_discarded=False):
@@ -90,8 +92,9 @@ class BasicExecutableExecutor(BasicExecutor, ABC):
         """
         This method calls all user defined filters that are to be applied to the executor tree.
         """
-        for cur_child_executor in self.all_child_executors:
-            cur_child_executor.filter_tree_for_user_filters()
+        if self.all_child_executors:
+            for cur_child_executor in self.all_child_executors:
+                cur_child_executor.filter_tree_for_user_filters()
 
     def execute(self, show_discarded=False):
         """
@@ -105,6 +108,8 @@ class BasicExecutableExecutor(BasicExecutor, ABC):
                 if self.has_runnable_tests():
                     self.fixture_manager.enter(self)
                     self.construct_result.set_result(ResultState.SUCCESS)
+                else:
+                    self.construct_result.set_result(ResultState.NOT_RUN)
 
                 self._body_execution(show_discarded=show_discarded)
             except Exception as exc:  # pylint: disable=broad-exception-caught
@@ -116,6 +121,8 @@ class BasicExecutableExecutor(BasicExecutor, ABC):
                     if self.fixture_manager.is_allowed_to_leave(self):
                         self.fixture_manager.leave(self)
                         self.teardown_result.set_result(ResultState.SUCCESS)
+                else:
+                    self.teardown_result.set_result(ResultState.NOT_RUN)
         except Exception as exc:  # pylint: disable=broad-exception-caught
             # this has to be a teardown fixture error
             traceback.print_exception(*sys.exc_info())

_balder/executor/basic_executor.py

@@ -38,7 +38,7 @@ class BasicExecutor(ABC):
 
     @property
     @abstractmethod
-    def all_child_executors(self) -> List[BasicExecutor]:
+    def all_child_executors(self) -> list[BasicExecutor] | None:
         """
         returns all child executors of this object or None if no child executors can exist (this element is a leaf)
         """
@@ -115,6 +115,32 @@ class BasicExecutor(ABC):
             return False
         return True
 
+    def has_skipped_tests(self) -> bool:
+        """
+        This method returns true if this executor element has at least one test that is marked to be skipped. The method
+        returns true if minimum one of its children has `prev_mark=SKIP`.
+        """
+        if self.all_child_executors is not None:
+            # the executor has child executors -> check them
+            for cur_child in self.all_child_executors:
+                if cur_child.has_skipped_tests():
+                    return True
+            return False
+        return False
+
+    def has_covered_by_tests(self) -> bool:
+        """
+        This method returns true if this executor element has at least one test that is marked as covered-by. The method
+        returns true if minimum one of its children has `prev_mark=COVERED_BY`.
+        """
+        if self.all_child_executors is not None:
+            # the executor has child executors -> check them
+            for cur_child in self.all_child_executors:
+                if cur_child.has_covered_by_tests():
+                    return True
+            return False
+        return False
+
     def get_all_base_instances_of_this_branch(
             self, with_type: Union[Type[Setup], Type[Scenario], Type[types.FunctionType]],
             only_runnable_elements: bool = True) -> List[Union[Setup, Scenario, object]]:
@@ -159,8 +185,9 @@ class BasicExecutor(ABC):
         """
         This method calls all user defined filters that are to be applied to the executor tree.
         """
-        for cur_child_executor in self.all_child_executors:
-            cur_child_executor.filter_tree_for_user_filters()
+        if self.all_child_executors:
+            for cur_child_executor in self.all_child_executors:
+                cur_child_executor.filter_tree_for_user_filters()
 
     def testsummary(self) -> ResultSummary:
         """
@@ -172,7 +199,7 @@ class BasicExecutor(ABC):
 
         if isinstance(self.body_result, TestcaseResult):
             setattr(summary, self.executor_result.value, 1)
-        else:
+        elif self.all_child_executors:
             for cur_child_exec in self.all_child_executors:
                 summary += cur_child_exec.testsummary()
         return summary

_balder/executor/executor_tree.py

@@ -38,7 +38,7 @@ class ExecutorTree(BasicExecutableExecutor):
     # ---------------------------------- PROPERTIES --------------------------------------------------------------------
 
     @property
-    def all_child_executors(self) -> List[BasicExecutableExecutor]:
+    def all_child_executors(self) -> List[BasicExecutableExecutor] | None:
         return self._setup_executors
 
     @property
@@ -63,11 +63,12 @@ class ExecutorTree(BasicExecutableExecutor):
 
     def _body_execution(self, show_discarded):
         for cur_setup_executor in self.get_setup_executors():
-            if cur_setup_executor.has_runnable_tests(consider_discarded_too=show_discarded):
+            prev_mark = cur_setup_executor.prev_mark
+            if cur_setup_executor.has_runnable_tests(show_discarded) or cur_setup_executor.has_skipped_tests():
                 cur_setup_executor.execute(show_discarded=show_discarded)
-            elif cur_setup_executor.prev_mark == PreviousExecutorMark.SKIP:
+            elif prev_mark == PreviousExecutorMark.SKIP:
                 cur_setup_executor.set_result_for_whole_branch(ResultState.SKIP)
-            elif cur_setup_executor.prev_mark == PreviousExecutorMark.COVERED_BY:
+            elif prev_mark == PreviousExecutorMark.COVERED_BY:
                 cur_setup_executor.set_result_for_whole_branch(ResultState.COVERED_BY)
             else:
                 cur_setup_executor.set_result_for_whole_branch(ResultState.NOT_RUN)

_balder/executor/parametrized_testcase_executor.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from typing import Any, TYPE_CHECKING
 
 from collections import OrderedDict
-from _balder.utils import inspect_method
+from _balder.utils.functions import get_method_type
 from .testcase_executor import TestcaseExecutor
 
 if TYPE_CHECKING:
@@ -39,7 +39,7 @@ class ParametrizedTestcaseExecutor(TestcaseExecutor):
         return super().full_test_name_str
 
     def get_all_test_method_args(self):
-        _, func_type = inspect_method(self.base_testcase_callable)
+        func_type = get_method_type(self.base_testcase_obj.__class__, self.base_testcase_callable)
         all_kwargs = self.fixture_manager.get_all_attribute_values(
             self,
             self.base_testcase_obj.__class__,