pytest

519def approx(expected, rel=None, abs=None, nan_ok: bool = False) -> ApproxBase:
520    """Assert that two numbers (or two ordered sequences of numbers) are equal to each other
521    within some tolerance.
522
523    Due to the :doc:`python:tutorial/floatingpoint`, numbers that we
524    would intuitively expect to be equal are not always so::
525
526        >>> 0.1 + 0.2 == 0.3
527        False
528
529    This problem is commonly encountered when writing tests, e.g. when making
530    sure that floating-point values are what you expect them to be.  One way to
531    deal with this problem is to assert that two floating-point numbers are
532    equal to within some appropriate tolerance::
533
534        >>> abs((0.1 + 0.2) - 0.3) < 1e-6
535        True
536
537    However, comparisons like this are tedious to write and difficult to
538    understand.  Furthermore, absolute comparisons like the one above are
539    usually discouraged because there's no tolerance that works well for all
540    situations.  ``1e-6`` is good for numbers around ``1``, but too small for
541    very big numbers and too big for very small ones.  It's better to express
542    the tolerance as a fraction of the expected value, but relative comparisons
543    like that are even more difficult to write correctly and concisely.
544
545    The ``approx`` class performs floating-point comparisons using a syntax
546    that's as intuitive as possible::
547
548        >>> from pytest import approx
549        >>> 0.1 + 0.2 == approx(0.3)
550        True
551
552    The same syntax also works for ordered sequences of numbers::
553
554        >>> (0.1 + 0.2, 0.2 + 0.4) == approx((0.3, 0.6))
555        True
556
557    ``numpy`` arrays::
558
559        >>> import numpy as np                                                          # doctest: +SKIP
560        >>> np.array([0.1, 0.2]) + np.array([0.2, 0.4]) == approx(np.array([0.3, 0.6])) # doctest: +SKIP
561        True
562
563    And for a ``numpy`` array against a scalar::
564
565        >>> import numpy as np                                         # doctest: +SKIP
566        >>> np.array([0.1, 0.2]) + np.array([0.2, 0.1]) == approx(0.3) # doctest: +SKIP
567        True
568
569    Only ordered sequences are supported, because ``approx`` needs
570    to infer the relative position of the sequences without ambiguity. This means
571    ``sets`` and other unordered sequences are not supported.
572
573    Finally, dictionary *values* can also be compared::
574
575        >>> {'a': 0.1 + 0.2, 'b': 0.2 + 0.4} == approx({'a': 0.3, 'b': 0.6})
576        True
577
578    The comparison will be true if both mappings have the same keys and their
579    respective values match the expected tolerances.
580
581    **Tolerances**
582
583    By default, ``approx`` considers numbers within a relative tolerance of
584    ``1e-6`` (i.e. one part in a million) of its expected value to be equal.
585    This treatment would lead to surprising results if the expected value was
586    ``0.0``, because nothing but ``0.0`` itself is relatively close to ``0.0``.
587    To handle this case less surprisingly, ``approx`` also considers numbers
588    within an absolute tolerance of ``1e-12`` of its expected value to be
589    equal.  Infinity and NaN are special cases.  Infinity is only considered
590    equal to itself, regardless of the relative tolerance.  NaN is not
591    considered equal to anything by default, but you can make it be equal to
592    itself by setting the ``nan_ok`` argument to True.  (This is meant to
593    facilitate comparing arrays that use NaN to mean "no data".)
594
595    Both the relative and absolute tolerances can be changed by passing
596    arguments to the ``approx`` constructor::
597
598        >>> 1.0001 == approx(1)
599        False
600        >>> 1.0001 == approx(1, rel=1e-3)
601        True
602        >>> 1.0001 == approx(1, abs=1e-3)
603        True
604
605    If you specify ``abs`` but not ``rel``, the comparison will not consider
606    the relative tolerance at all.  In other words, two numbers that are within
607    the default relative tolerance of ``1e-6`` will still be considered unequal
608    if they exceed the specified absolute tolerance.  If you specify both
609    ``abs`` and ``rel``, the numbers will be considered equal if either
610    tolerance is met::
611
612        >>> 1 + 1e-8 == approx(1)
613        True
614        >>> 1 + 1e-8 == approx(1, abs=1e-12)
615        False
616        >>> 1 + 1e-8 == approx(1, rel=1e-6, abs=1e-12)
617        True
618
619    You can also use ``approx`` to compare nonnumeric types, or dicts and
620    sequences containing nonnumeric types, in which case it falls back to
621    strict equality. This can be useful for comparing dicts and sequences that
622    can contain optional values::
623
624        >>> {"required": 1.0000005, "optional": None} == approx({"required": 1, "optional": None})
625        True
626        >>> [None, 1.0000005] == approx([None,1])
627        True
628        >>> ["foo", 1.0000005] == approx([None,1])
629        False
630
631    If you're thinking about using ``approx``, then you might want to know how
632    it compares to other good ways of comparing floating-point numbers.  All of
633    these algorithms are based on relative and absolute tolerances and should
634    agree for the most part, but they do have meaningful differences:
635
636    - ``math.isclose(a, b, rel_tol=1e-9, abs_tol=0.0)``:  True if the relative
637      tolerance is met w.r.t. either ``a`` or ``b`` or if the absolute
638      tolerance is met.  Because the relative tolerance is calculated w.r.t.
639      both ``a`` and ``b``, this test is symmetric (i.e.  neither ``a`` nor
640      ``b`` is a "reference value").  You have to specify an absolute tolerance
641      if you want to compare to ``0.0`` because there is no tolerance by
642      default.  More information: :py:func:`math.isclose`.
643
644    - ``numpy.isclose(a, b, rtol=1e-5, atol=1e-8)``: True if the difference
645      between ``a`` and ``b`` is less that the sum of the relative tolerance
646      w.r.t. ``b`` and the absolute tolerance.  Because the relative tolerance
647      is only calculated w.r.t. ``b``, this test is asymmetric and you can
648      think of ``b`` as the reference value.  Support for comparing sequences
649      is provided by :py:func:`numpy.allclose`.  More information:
650      :std:doc:`numpy:reference/generated/numpy.isclose`.
651
652    - ``unittest.TestCase.assertAlmostEqual(a, b)``: True if ``a`` and ``b``
653      are within an absolute tolerance of ``1e-7``.  No relative tolerance is
654      considered , so this function is not appropriate for very large or very
655      small numbers.  Also, it's only available in subclasses of ``unittest.TestCase``
656      and it's ugly because it doesn't follow PEP8.  More information:
657      :py:meth:`unittest.TestCase.assertAlmostEqual`.
658
659    - ``a == pytest.approx(b, rel=1e-6, abs=1e-12)``: True if the relative
660      tolerance is met w.r.t. ``b`` or if the absolute tolerance is met.
661      Because the relative tolerance is only calculated w.r.t. ``b``, this test
662      is asymmetric and you can think of ``b`` as the reference value.  In the
663      special case that you explicitly specify an absolute tolerance but not a
664      relative tolerance, only the absolute tolerance is considered.
665
666    .. note::
667
668        ``approx`` can handle numpy arrays, but we recommend the
669        specialised test helpers in :std:doc:`numpy:reference/routines.testing`
670        if you need support for comparisons, NaNs, or ULP-based tolerances.
671
672        To match strings using regex, you can use
673        `Matches <https://github.com/asottile/re-assert#re_assertmatchespattern-str-args-kwargs>`_
674        from the
675        `re_assert package <https://github.com/asottile/re-assert>`_.
676
677    .. warning::
678
679       .. versionchanged:: 3.2
680
681       In order to avoid inconsistent behavior, :py:exc:`TypeError` is
682       raised for ``>``, ``>=``, ``<`` and ``<=`` comparisons.
683       The example below illustrates the problem::
684
685           assert approx(0.1) > 0.1 + 1e-10  # calls approx(0.1).__gt__(0.1 + 1e-10)
686           assert 0.1 + 1e-10 > approx(0.1)  # calls approx(0.1).__lt__(0.1 + 1e-10)
687
688       In the second example one expects ``approx(0.1).__le__(0.1 + 1e-10)``
689       to be called. But instead, ``approx(0.1).__lt__(0.1 + 1e-10)`` is used to
690       comparison. This is because the call hierarchy of rich comparisons
691       follows a fixed behavior. More information: :py:meth:`object.__ge__`
692
693    .. versionchanged:: 3.7.1
694       ``approx`` raises ``TypeError`` when it encounters a dict value or
695       sequence element of nonnumeric type.
696
697    .. versionchanged:: 6.1.0
698       ``approx`` falls back to strict equality for nonnumeric types instead
699       of raising ``TypeError``.
700    """
701    # Delegate the comparison to a class that knows how to deal with the type
702    # of the expected value (e.g. int, float, list, dict, numpy.array, etc).
703    #
704    # The primary responsibility of these classes is to implement ``__eq__()``
705    # and ``__repr__()``.  The former is used to actually check if some
706    # "actual" value is equivalent to the given expected value within the
707    # allowed tolerance.  The latter is used to show the user the expected
708    # value and tolerance, in the case that a test failed.
709    #
710    # The actual logic for making approximate comparisons can be found in
711    # ApproxScalar, which is used to compare individual numbers.  All of the
712    # other Approx classes eventually delegate to this class.  The ApproxBase
713    # class provides some convenient methods and overloads, but isn't really
714    # essential.
715
716    __tracebackhide__ = True
717
718    if isinstance(expected, Decimal):
719        cls: Type[ApproxBase] = ApproxDecimal
720    elif isinstance(expected, Mapping):
721        cls = ApproxMapping
722    elif _is_numpy_array(expected):
723        expected = _as_numpy_array(expected)
724        cls = ApproxNumpy
725    elif (
726        hasattr(expected, "__getitem__")
727        and isinstance(expected, Sized)
728        and not isinstance(expected, (str, bytes))
729    ):
730        cls = ApproxSequenceLike
731    elif isinstance(expected, Collection) and not isinstance(expected, (str, bytes)):
732        msg = f"pytest.approx() only supports ordered sequences, but got: {expected!r}"
733        raise TypeError(msg)
734    else:
735        cls = ApproxScalar
736
737    return cls(expected, rel, abs, nan_ok)

 58@final
 59@dataclasses.dataclass
 60class Cache:
 61    """Instance of the `cache` fixture."""
 62
 63    _cachedir: Path = dataclasses.field(repr=False)
 64    _config: Config = dataclasses.field(repr=False)
 65
 66    # Sub-directory under cache-dir for directories created by `mkdir()`.
 67    _CACHE_PREFIX_DIRS = "d"
 68
 69    # Sub-directory under cache-dir for values created by `set()`.
 70    _CACHE_PREFIX_VALUES = "v"
 71
 72    def __init__(
 73        self, cachedir: Path, config: Config, *, _ispytest: bool = False
 74    ) -> None:
 75        check_ispytest(_ispytest)
 76        self._cachedir = cachedir
 77        self._config = config
 78
 79    @classmethod
 80    def for_config(cls, config: Config, *, _ispytest: bool = False) -> "Cache":
 81        """Create the Cache instance for a Config.
 82
 83        :meta private:
 84        """
 85        check_ispytest(_ispytest)
 86        cachedir = cls.cache_dir_from_config(config, _ispytest=True)
 87        if config.getoption("cacheclear") and cachedir.is_dir():
 88            cls.clear_cache(cachedir, _ispytest=True)
 89        return cls(cachedir, config, _ispytest=True)
 90
 91    @classmethod
 92    def clear_cache(cls, cachedir: Path, _ispytest: bool = False) -> None:
 93        """Clear the sub-directories used to hold cached directories and values.
 94
 95        :meta private:
 96        """
 97        check_ispytest(_ispytest)
 98        for prefix in (cls._CACHE_PREFIX_DIRS, cls._CACHE_PREFIX_VALUES):
 99            d = cachedir / prefix
100            if d.is_dir():
101                rm_rf(d)
102
103    @staticmethod
104    def cache_dir_from_config(config: Config, *, _ispytest: bool = False) -> Path:
105        """Get the path to the cache directory for a Config.
106
107        :meta private:
108        """
109        check_ispytest(_ispytest)
110        return resolve_from_str(config.getini("cache_dir"), config.rootpath)
111
112    def warn(self, fmt: str, *, _ispytest: bool = False, **args: object) -> None:
113        """Issue a cache warning.
114
115        :meta private:
116        """
117        check_ispytest(_ispytest)
118        import warnings
119
120        from _pytest.warning_types import PytestCacheWarning
121
122        warnings.warn(
123            PytestCacheWarning(fmt.format(**args) if args else fmt),
124            self._config.hook,
125            stacklevel=3,
126        )
127
128    def _mkdir(self, path: Path) -> None:
129        self._ensure_cache_dir_and_supporting_files()
130        path.mkdir(exist_ok=True, parents=True)
131
132    def mkdir(self, name: str) -> Path:
133        """Return a directory path object with the given name.
134
135        If the directory does not yet exist, it will be created. You can use
136        it to manage files to e.g. store/retrieve database dumps across test
137        sessions.
138
139        .. versionadded:: 7.0
140
141        :param name:
142            Must be a string not containing a ``/`` separator.
143            Make sure the name contains your plugin or application
144            identifiers to prevent clashes with other cache users.
145        """
146        path = Path(name)
147        if len(path.parts) > 1:
148            raise ValueError("name is not allowed to contain path separators")
149        res = self._cachedir.joinpath(self._CACHE_PREFIX_DIRS, path)
150        self._mkdir(res)
151        return res
152
153    def _getvaluepath(self, key: str) -> Path:
154        return self._cachedir.joinpath(self._CACHE_PREFIX_VALUES, Path(key))
155
156    def get(self, key: str, default):
157        """Return the cached value for the given key.
158
159        If no value was yet cached or the value cannot be read, the specified
160        default is returned.
161
162        :param key:
163            Must be a ``/`` separated value. Usually the first
164            name is the name of your plugin or your application.
165        :param default:
166            The value to return in case of a cache-miss or invalid cache value.
167        """
168        path = self._getvaluepath(key)
169        try:
170            with path.open("r", encoding="UTF-8") as f:
171                return json.load(f)
172        except (ValueError, OSError):
173            return default
174
175    def set(self, key: str, value: object) -> None:
176        """Save value for the given key.
177
178        :param key:
179            Must be a ``/`` separated value. Usually the first
180            name is the name of your plugin or your application.
181        :param value:
182            Must be of any combination of basic python types,
183            including nested types like lists of dictionaries.
184        """
185        path = self._getvaluepath(key)
186        try:
187            self._mkdir(path.parent)
188        except OSError as exc:
189            self.warn(
190                f"could not create cache path {path}: {exc}",
191                _ispytest=True,
192            )
193            return
194        data = json.dumps(value, ensure_ascii=False, indent=2)
195        try:
196            f = path.open("w", encoding="UTF-8")
197        except OSError as exc:
198            self.warn(
199                f"cache could not write path {path}: {exc}",
200                _ispytest=True,
201            )
202        else:
203            with f:
204                f.write(data)
205
206    def _ensure_cache_dir_and_supporting_files(self) -> None:
207        """Create the cache dir and its supporting files."""
208        if self._cachedir.is_dir():
209            return
210
211        self._cachedir.parent.mkdir(parents=True, exist_ok=True)
212        with tempfile.TemporaryDirectory(
213            prefix="pytest-cache-files-",
214            dir=self._cachedir.parent,
215        ) as newpath:
216            path = Path(newpath)
217            with open(path.joinpath("README.md"), "xt", encoding="UTF-8") as f:
218                f.write(README_CONTENT)
219            with open(path.joinpath(".gitignore"), "xt", encoding="UTF-8") as f:
220                f.write("# Created by pytest automatically.\n*\n")
221            with open(path.joinpath("CACHEDIR.TAG"), "xb") as f:
222                f.write(CACHEDIR_TAG_CONTENT)
223
224            path.rename(self._cachedir)
225            # Create a directory in place of the one we just moved so that `TemporaryDirectory`'s
226            # cleanup doesn't complain.
227            #
228            # TODO: pass ignore_cleanup_errors=True when we no longer support python < 3.10. See
229            # https://github.com/python/cpython/issues/74168. Note that passing delete=False would
230            # do the wrong thing in case of errors and isn't supported until python 3.12.
231            path.mkdir()

270@final
271@dataclasses.dataclass
272class CallInfo(Generic[TResult]):
273    """Result/Exception info of a function invocation."""
274
275    _result: Optional[TResult]
276    #: The captured exception of the call, if it raised.
277    excinfo: Optional[ExceptionInfo[BaseException]]
278    #: The system time when the call started, in seconds since the epoch.
279    start: float
280    #: The system time when the call ended, in seconds since the epoch.
281    stop: float
282    #: The call duration, in seconds.
283    duration: float
284    #: The context of invocation: "collect", "setup", "call" or "teardown".
285    when: Literal["collect", "setup", "call", "teardown"]
286
287    def __init__(
288        self,
289        result: Optional[TResult],
290        excinfo: Optional[ExceptionInfo[BaseException]],
291        start: float,
292        stop: float,
293        duration: float,
294        when: Literal["collect", "setup", "call", "teardown"],
295        *,
296        _ispytest: bool = False,
297    ) -> None:
298        check_ispytest(_ispytest)
299        self._result = result
300        self.excinfo = excinfo
301        self.start = start
302        self.stop = stop
303        self.duration = duration
304        self.when = when
305
306    @property
307    def result(self) -> TResult:
308        """The return value of the call, if it didn't raise.
309
310        Can only be accessed if excinfo is None.
311        """
312        if self.excinfo is not None:
313            raise AttributeError(f"{self!r} has no valid result")
314        # The cast is safe because an exception wasn't raised, hence
315        # _result has the expected function return type (which may be
316        #  None, that's why a cast and not an assert).
317        return cast(TResult, self._result)
318
319    @classmethod
320    def from_call(
321        cls,
322        func: Callable[[], TResult],
323        when: Literal["collect", "setup", "call", "teardown"],
324        reraise: Optional[
325            Union[Type[BaseException], Tuple[Type[BaseException], ...]]
326        ] = None,
327    ) -> "CallInfo[TResult]":
328        """Call func, wrapping the result in a CallInfo.
329
330        :param func:
331            The function to call. Called without arguments.
332        :param when:
333            The phase in which the function is called.
334        :param reraise:
335            Exception or exceptions that shall propagate if raised by the
336            function, instead of being wrapped in the CallInfo.
337        """
338        excinfo = None
339        start = timing.time()
340        precise_start = timing.perf_counter()
341        try:
342            result: Optional[TResult] = func()
343        except BaseException:
344            excinfo = ExceptionInfo.from_current()
345            if reraise is not None and isinstance(excinfo.value, reraise):
346                raise
347            result = None
348        # use the perf counter
349        precise_stop = timing.perf_counter()
350        duration = precise_stop - precise_start
351        stop = timing.time()
352        return cls(
353            start=start,
354            stop=stop,
355            duration=duration,
356            when=when,
357            result=result,
358            excinfo=excinfo,
359            _ispytest=True,
360        )
361
362    def __repr__(self) -> str:
363        if self.excinfo is None:
364            return f"<CallInfo when={self.when!r} result: {self._result!r}>"
365        return f"<CallInfo when={self.when!r} excinfo={self.excinfo!r}>"

895class CaptureFixture(Generic[AnyStr]):
896    """Object returned by the :fixture:`capsys`, :fixture:`capsysbinary`,
897    :fixture:`capfd` and :fixture:`capfdbinary` fixtures."""
898
899    def __init__(
900        self,
901        captureclass: Type[CaptureBase[AnyStr]],
902        request: SubRequest,
903        *,
904        _ispytest: bool = False,
905    ) -> None:
906        check_ispytest(_ispytest)
907        self.captureclass: Type[CaptureBase[AnyStr]] = captureclass
908        self.request = request
909        self._capture: Optional[MultiCapture[AnyStr]] = None
910        self._captured_out: AnyStr = self.captureclass.EMPTY_BUFFER
911        self._captured_err: AnyStr = self.captureclass.EMPTY_BUFFER
912
913    def _start(self) -> None:
914        if self._capture is None:
915            self._capture = MultiCapture(
916                in_=None,
917                out=self.captureclass(1),
918                err=self.captureclass(2),
919            )
920            self._capture.start_capturing()
921
922    def close(self) -> None:
923        if self._capture is not None:
924            out, err = self._capture.pop_outerr_to_orig()
925            self._captured_out += out
926            self._captured_err += err
927            self._capture.stop_capturing()
928            self._capture = None
929
930    def readouterr(self) -> CaptureResult[AnyStr]:
931        """Read and return the captured output so far, resetting the internal
932        buffer.
933
934        :returns:
935            The captured content as a namedtuple with ``out`` and ``err``
936            string attributes.
937        """
938        captured_out, captured_err = self._captured_out, self._captured_err
939        if self._capture is not None:
940            out, err = self._capture.readouterr()
941            captured_out += out
942            captured_err += err
943        self._captured_out = self.captureclass.EMPTY_BUFFER
944        self._captured_err = self.captureclass.EMPTY_BUFFER
945        return CaptureResult(captured_out, captured_err)
946
947    def _suspend(self) -> None:
948        """Suspend this fixture's own capturing temporarily."""
949        if self._capture is not None:
950            self._capture.suspend_capturing()
951
952    def _resume(self) -> None:
953        """Resume this fixture's own capturing temporarily."""
954        if self._capture is not None:
955            self._capture.resume_capturing()
956
957    def _is_started(self) -> bool:
958        """Whether actively capturing -- not disabled or closed."""
959        if self._capture is not None:
960            return self._capture.is_started()
961        return False
962
963    @contextlib.contextmanager
964    def disabled(self) -> Generator[None, None, None]:
965        """Temporarily disable capturing while inside the ``with`` block."""
966        capmanager: CaptureManager = self.request.config.pluginmanager.getplugin(
967            "capturemanager"
968        )
969        with capmanager.global_and_fixture_disabled():
970            yield

726class Class(PyCollector):
727    """Collector for test methods (and nested classes) in a Python class."""
728
729    @classmethod
730    def from_parent(cls, parent, *, name, obj=None, **kw) -> "Self":  # type: ignore[override]
731        """The public constructor."""
732        return super().from_parent(name=name, parent=parent, **kw)
733
734    def newinstance(self):
735        return self.obj()
736
737    def collect(self) -> Iterable[Union[nodes.Item, nodes.Collector]]:
738        if not safe_getattr(self.obj, "__test__", True):
739            return []
740        if hasinit(self.obj):
741            assert self.parent is not None
742            self.warn(
743                PytestCollectionWarning(
744                    f"cannot collect test class {self.obj.__name__!r} because it has a "
745                    f"__init__ constructor (from: {self.parent.nodeid})"
746                )
747            )
748            return []
749        elif hasnew(self.obj):
750            assert self.parent is not None
751            self.warn(
752                PytestCollectionWarning(
753                    f"cannot collect test class {self.obj.__name__!r} because it has a "
754                    f"__new__ constructor (from: {self.parent.nodeid})"
755                )
756            )
757            return []
758
759        self._register_setup_class_fixture()
760        self._register_setup_method_fixture()
761
762        self.session._fixturemanager.parsefactories(self.newinstance(), self.nodeid)
763
764        return super().collect()
765
766    def _register_setup_class_fixture(self) -> None:
767        """Register an autouse, class scoped fixture into the collected class object
768        that invokes setup_class/teardown_class if either or both are available.
769
770        Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with
771        other fixtures (#517).
772        """
773        setup_class = _get_first_non_fixture_func(self.obj, ("setup_class",))
774        teardown_class = _get_first_non_fixture_func(self.obj, ("teardown_class",))
775        if setup_class is None and teardown_class is None:
776            return
777
778        def xunit_setup_class_fixture(request) -> Generator[None, None, None]:
779            cls = request.cls
780            if setup_class is not None:
781                func = getimfunc(setup_class)
782                _call_with_optional_argument(func, cls)
783            yield
784            if teardown_class is not None:
785                func = getimfunc(teardown_class)
786                _call_with_optional_argument(func, cls)
787
788        self.session._fixturemanager._register_fixture(
789            # Use a unique name to speed up lookup.
790            name=f"_xunit_setup_class_fixture_{self.obj.__qualname__}",
791            func=xunit_setup_class_fixture,
792            nodeid=self.nodeid,
793            scope="class",
794            autouse=True,
795        )
796
797    def _register_setup_method_fixture(self) -> None:
798        """Register an autouse, function scoped fixture into the collected class object
799        that invokes setup_method/teardown_method if either or both are available.
800
801        Using a fixture to invoke these methods ensures we play nicely and unsurprisingly with
802        other fixtures (#517).
803        """
804        setup_name = "setup_method"
805        setup_method = _get_first_non_fixture_func(self.obj, (setup_name,))
806        teardown_name = "teardown_method"
807        teardown_method = _get_first_non_fixture_func(self.obj, (teardown_name,))
808        if setup_method is None and teardown_method is None:
809            return
810
811        def xunit_setup_method_fixture(request) -> Generator[None, None, None]:
812            instance = request.instance
813            method = request.function
814            if setup_method is not None:
815                func = getattr(instance, setup_name)
816                _call_with_optional_argument(func, method)
817            yield
818            if teardown_method is not None:
819                func = getattr(instance, teardown_name)
820                _call_with_optional_argument(func, method)
821
822        self.session._fixturemanager._register_fixture(
823            # Use a unique name to speed up lookup.
824            name=f"_xunit_setup_method_fixture_{self.obj.__qualname__}",
825            func=xunit_setup_method_fixture,
826            nodeid=self.nodeid,
827            scope="function",
828            autouse=True,
829        )