pytest

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

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

271@final
272@dataclasses.dataclass
273class CallInfo(Generic[TResult]):
274    """Result/Exception info of a function invocation."""
275
276    _result: TResult | None
277    #: The captured exception of the call, if it raised.
278    excinfo: ExceptionInfo[BaseException] | None
279    #: The system time when the call started, in seconds since the epoch.
280    start: float
281    #: The system time when the call ended, in seconds since the epoch.
282    stop: float
283    #: The call duration, in seconds.
284    duration: float
285    #: The context of invocation: "collect", "setup", "call" or "teardown".
286    when: Literal["collect", "setup", "call", "teardown"]
287
288    def __init__(
289        self,
290        result: TResult | None,
291        excinfo: ExceptionInfo[BaseException] | None,
292        start: float,
293        stop: float,
294        duration: float,
295        when: Literal["collect", "setup", "call", "teardown"],
296        *,
297        _ispytest: bool = False,
298    ) -> None:
299        check_ispytest(_ispytest)
300        self._result = result
301        self.excinfo = excinfo
302        self.start = start
303        self.stop = stop
304        self.duration = duration
305        self.when = when
306
307    @property
308    def result(self) -> TResult:
309        """The return value of the call, if it didn't raise.
310
311        Can only be accessed if excinfo is None.
312        """
313        if self.excinfo is not None:
314            raise AttributeError(f"{self!r} has no valid result")
315        # The cast is safe because an exception wasn't raised, hence
316        # _result has the expected function return type (which may be
317        #  None, that's why a cast and not an assert).
318        return cast(TResult, self._result)
319
320    @classmethod
321    def from_call(
322        cls,
323        func: Callable[[], TResult],
324        when: Literal["collect", "setup", "call", "teardown"],
325        reraise: type[BaseException] | tuple[type[BaseException], ...] | None = None,
326    ) -> CallInfo[TResult]:
327        """Call func, wrapping the result in a CallInfo.
328
329        :param func:
330            The function to call. Called without arguments.
331        :type func: Callable[[], _pytest.runner.TResult]
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: TResult | None = 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}>"

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

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