9[gddlmZddlmZddlmZddlmZddlZddlm Z ddl Z ddl Z ddl m Z ddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlZddlmZerddl m!Z! d2dZ"GddZ#dZ$Gdde#Z%Gdde#Z&Gdd e#Z'Gd!d"e#Z(Gd#d$e(Z)d3d4d%Z*d5d&Z+d6d'Z,d7d(Z-ed)e.*Z/ed+d, d8d-Z0e d9d.Z0 d:d/Z0ejbe0_1eGd0d1eejdjfe/Z4y);) annotations) Collection)Sized)DecimalN)Complex) TracebackType)Any)Callable)cast)ContextManager)final)Mapping)overload)Pattern)Sequence)Tuple)Type) TYPE_CHECKING)TypeVar)fail)ndarrayct|}|jddgd}|D]W\}} } t|dt||d<t|dt| |d<t|dt| |d<Ydt|d|dd |d |g|D cgc]%\} } } | d |dd | d |dd | d |d'c} } } z} | Scc} } } w) Nr)IndexObtainedExpected)rrrz(comparison failed. Mismatched elements: z / :zMax absolute difference: zMax relative difference: 2 #L>2 ,8 +7 'GXx 1Yq\N" #3x)A,/?&@HQyYZ|nL\C]^+7  K   s*C cbeZdZdZdZdZd ddZddZddZddZ dZ dZ dd Z dd Z d Zdd Zy) ApproxBasezhProvide shared utilities for making approximate comparisons between numbers or sequences of numbers.Ndc`d}||_||_||_||_|j y)NT)r.absrelnan_ok _check_type)selfr.r8r7r9__tracebackhide__s r1__init__zApproxBase.__init__Gs0     ctNNotImplementedErrorr;s r1__repr__zApproxBase.__repr__Os!!r>cdd|d|gS)Nzcomparison failedz Obtained: z Expected: )r; other_sides r1 _repr_comparezApproxBase._repr_compareRs#  %   r>cJtfdj|DS)Nc3LK|]\}}|j|k(ywr@_approx_scalar).0axr;s r1 z$ApproxBase.__eq__..Zs* 4SDAqA$$Q' '4Ss!$)all_yield_comparisonsr;actuals` r1__eq__zApproxBase.__eq__Ys( 484K4KF4S   r>cd}td)NTzVapprox() is not supported in a boolean context. Did you mean: `assert a == approx(b)`?)AssertionError)r;r<s r1__bool__zApproxBase.__bool__^s  e  r>c||k( Sr@rFrSs r1__ne__zApproxBase.__ne__gsdN##r>ct|tr-t||j|j|j St ||j|j|j S)N)r8r7r9) isinstancer ApproxDecimalr8r7r9 ApproxScalar)r;rOs r1rLzApproxBase._approx_scalarjsF a ! dhht{{S SA488$++NNr>ct)zoYield all the pairs of numbers to be compared. This is used to implement the `__eq__` method. rArSs r1rRzApproxBase._yield_comparisonsos "!r>cy)zNNF)r9boolreturnNonercstr)rGr rc list[str]rcrb)rcr^rcrd)__name__ __module__ __qualname____doc____array_ufunc____array_priority__r=rDrHrUrX__hash__rZrLrRr:rFr>r1r4r4?sJ(O"   H$O "Kr>r4ct|ttfrt|}|fd|DSt |r|Dcgc]}t |c}S|Scc}w)z=Recursively map a function over a sequence of arbitrary depthc36K|]}t|ywr@)_recursive_sequence_map)rMxifs r1rPz*_recursive_sequence_map..sC2/26s)r\r tupletype_is_sequence_likers)rurOseq_typerts` r1rsrss^!dE]#7CCCC 1 9:;2'2.;;t c Nddl}ddl} dd}|jj}t |j |jj }t|}|J||jk7rdd|d|jgS|jj}|j } |j } g} |jd|DD]y} ||| } ||| }| |k7st| j|z }t| |} |dk(r |j} nt| |t|z } | j| {| D cgc]0} t| t||| t||| f2}} t|j||| | | Scc} w) Nrc"|}|D]}||} |S)z Helper function to get the value out of a nested list, given an n-dimensional index. This mimics numpy's indexing, but for raw nested python lists. rF) nested_listnd_indexvalueis r1get_value_from_nested_listz=ApproxNumpy._repr_compare..get_value_from_nested_lists!%EaLr>z3Impossible to compare arrays with different shapes.zShapes:  and c32K|]}t|ywr@)range)rMrs r1rPz,ApproxNumpy._repr_compare..s(J>aq>s)rz list[Any]rztuple[Any, ...]rcr ) itertoolsmathr.shapersrLr_as_numpy_arraysizeinfproductr7r"appendrfr2)r;rGrrrnp_array_shapeapprox_side_as_seqother_side_as_arrayr&r(r)r'r, approx_value other_valueabs_diffr%s r1rHzApproxNumpy._repr_compares " .=   ,,4   !5!5!7  .j9"... 066 6E>*%0C0I0I/JK  "]]//y y  &Y&&(J>(JKE56H%PL45H%PK{*|44{BC"<: #%#'88L#&|XK@P5P#QL$$U+L$'  ' E ./BEJK./A5IJ  '   MM         s5F"cddl}|j|s |j|}|j|s$|j |j j k7ryt|!|S#t$r}t d|d|d}~wwxYw)Nrzcannot compare 'z' to numpy.ndarrayF) numpyisscalarasarray Exception TypeErrorrr.superrU)r;rTnpe __class__s r1rUzApproxNumpy.__eq__s{{6" VF+{{6"v||t}}7J7J'Jw~f%%  V"26(:L MNTUU VsA-- B 6BB c#Kddl}|j|rL|j|jjD]#}||j|j f%y|j|jjD]4}||j |j|j f6yw)Nr)rrndindexr.ritem)r;rTrrs r1rRzApproxNumpy._yield_comparisonss ;;v ZZ 3 34dmmA.335555ZZ 3 34Qinn& a(8(=(=(???5sB?Cre)rGzndarray | list[Any]rcrgrh) rjrkrlrmrDrHrUrR __classcell__rs@r1r{r{sR+ > @& @r>r{cBeZdZdZddZddZd fd ZdZd dZxZ S) ApproxMappingzyPerform approximate comparisons where the expected value is a mapping with numeric values (the keys can be anything).c d|jjDcic]\}}||j|c}}dScc}}wr})r.itemsrL)r;kvs r1rDzApproxMapping.__repr__sHATATAVWAVA1d11!44AVW[[\]]WsAc *ddl}|jjDcic]\}}||j|}}}t |}|j }|j }g} t |j|jD]\\} } } | | k7s| jp| n t|t| j| z }| jdk(r |j }n/t|t| j| z | jz }| j| | D cgc](} t| t|| t|| f*}} t|j||| ||Scc}}w#t$rYqwxYwcc} w)Nrr)rr.rrLr#rzipvaluesr"r7ZeroDivisionErrorrrfr2)r;rGrrrapprox_side_as_mapr&r(r)r' approx_keyrrkeyr%s r1rHzApproxMapping._repr_compares37--2E2E2G 2G$!QAt""1% %2G  !!34y y  7:  $ $ & (9(9(;8 3 &Z {*((49P'*(#l.C.Ck.Q*R( (00C7+/88L+. , #%1%:%:[%H&2&;&;%<!",L$$Z0+8 2% $Xs:c?+S1CC1H-I J$   MM        I 6- sE;.A-F2-F F  F c t|jt|jjk7ry t||S#t$rYywxYwNF)setkeysr.AttributeErrorrrUr;rTrs r1rUzApproxMapping.__eq__)sZ 6;;=!S););)=%>>? w~f%%  s=A AAc#vK|jjD]}|||j|fywr@)r.r)r;rTrs r1rRz ApproxMapping._yield_comparisons2s5##%A)T]]1-- -&s79c d}|jjD]_\}}t|t|js&d}t |j ||t j|jy)NTz[pytest.approx() does not support nested dictionaries: key={!r} value={!r} full mapping={})r.rr\rwrformatpprintpformat)r;r<rrmsgs r1r:zApproxMapping._check_type6s` ----/JC%dmm!45t 3v~~dmm7T UVV0r>re)rGzMapping[object, float]rcrgrhri rjrkrlrmrDrHrUrRr:rrs@r1rrs$7^. `&.Wr>rcBeZdZdZddZddZd fd ZdZd dZxZ S) ApproxSequenceLikezRPerform approximate comparisons where the expected value is a sequence of numbers.ctj}|ttfvrt}d|fdjDdS)Nr~c3@K|]}j|ywr@rK)rMrOr;s r1rPz.ApproxSequenceLike.__repr__..Es!P-Q$"5"5a"8-r)rwr.rvr )r;rys` r1rDzApproxSequenceLike.__repr__AsB & E4= (H!P$--!PPSSTUUr>c ddl}t|jt|k7r&ddt|jdt|gSt|j|j}t|}|j }|j }g}t t||D]m\}\} } | | k7st| j| z } t|| }| dk(r |j }nt|| t| z }|j|o|Dcgc](}t|t||t||f*} }t|j| ||||Scc}w)Nrz1Impossible to compare lists with different sizes.z Lengths: rr) rr#r.rsrLr enumeraterr7r"rrfr2) r;rGrrr&r(r)r'rrrrr%s r1rHz ApproxSequenceLike._repr_compareGsu t}} Z 0CC ./uS_4EF  5T5H5H$--X !34y y  .7 "J // *A* k{*|44{BC"<: #%#'88L#&|XK@P5P#QL$$Q'/ # "VSA'-?-B)C D"   MM         s-E%c t|t|jk7ry t||S#t$rYywxYwr)r#r.rrrUrs r1rUzApproxSequenceLike.__eq__psJ 6{c$--001w~f%%  s!5 AAc.t||jSr@)rr.rSs r1rRz%ApproxSequenceLike._yield_comparisonsxs64==))r>c d}t|jD]_\}}t|t|js&d}t |j ||t j|jy)NTz]pytest.approx() does not support nested data structures: {!r} at index {} full sequence: {})rr.r\rwrrrr)r;r<r,rOrs r1r:zApproxSequenceLike._check_type{s\ !$--0HE1!T$--01v 1eV^^DMM5R STT1r>re)rGzSequence[float]rcrgrhrirrs@r1rr>s"\V ' R&*Ur>rcReZdZUdZdZded<dZded<d dZd dZd Z e d Z y ) r^zLPerform approximate comparisons where the expected value is a single number.g-q=zfloat | DecimalDEFAULT_ABSOLUTE_TOLERANCEgư>DEFAULT_RELATIVE_TOLERANCEc2t|jtsdt|jttfrDt j t|jxst|jtrt|jS |jd}t|jtr:|jjr$t j |js|dz }|jd|S#t$rd}YwxYw)uReturn a string communicating both the expected value and the tolerance for the comparison being made. For example, ``1.0 ± 1e-6``, ``(3+4j) ± 5e-6 ∠ ±180°``. z.1eu ∠ ±180°z???u ± ) r\r.rbrrrisinfr7rf toleranceimag ValueError)r;vetted_tolerances r1rDzApproxScalar.__repr__s t}}d +t}}w.@Azz#dmm,O 4==$0OPt}}% % %"&..!5 4=='2MM&& 4>>2 N2 --%5$677 %$  %sA"D DDct|}|tfd|jDStjt rt|t sy|jk(rytjt s6tjt tfrt|t tfsytjtjr,jxrtjt|Stjtjrytj|z jk}|S)ziReturn whether the given value is equal to the expected value within the pre-specified tolerance.c3@K|]}j|ywr@)rU)rMrNr;s r1rPz&ApproxScalar.__eq__..s<|!t{{1~|rFT)rrQflatr\r.rbrrrisnanr7r9rr)r;rTrresults` r1rUzApproxScalar.__eq__s"&)  Ncd}||j|j}|dkrtd|tj|r td|j |j|S||j |j t|jz}|dkrtd|tj|r tdt||S)zReturn the tolerance for the comparison. This could be either an absolute tolerance or a relative tolerance, depending on what the user specified or which would be larger. c||S|Sr@rF)rOdefaults r1 set_defaultz+ApproxScalar.tolerance..set_defaults 1 27 2r>rz&absolute tolerance can't be negative: z absolute tolerance can't be NaN.z&relative tolerance can't be negative: z relative tolerance can't be NaN.) r7rrrrr8rr.r")r;rabsolute_tolerancerelative_tolerances r1rzApproxScalar.tolerances 3 )43R3RS  !89K8LM  ::( )?@ @ 88 xx#))) HHd55    !89K8LM  ::( )?@ @%'9::r>rerh) rjrkrlrmr__annotations__rrDrUrppropertyrrFr>r1r^r^sAV3872668>*ZH ,;,;r>r^c0eZdZdZedZedZy)r]zFPerform approximate comparisons where the expected value is a Decimal.z1e-12z1e-6N)rjrkrlrmrrrrFr>r1r]r] sP!(!1!(r>r]cNd}t|trt}nt|trt}nkt |rt |}t}nNt|rt}n>> 0.1 + 0.2 == 0.3 False This problem is commonly encountered when writing tests, e.g. when making sure that floating-point values are what you expect them to be. One way to deal with this problem is to assert that two floating-point numbers are equal to within some appropriate tolerance:: >>> abs((0.1 + 0.2) - 0.3) < 1e-6 True However, comparisons like this are tedious to write and difficult to understand. Furthermore, absolute comparisons like the one above are usually discouraged because there's no tolerance that works well for all situations. ``1e-6`` is good for numbers around ``1``, but too small for very big numbers and too big for very small ones. It's better to express the tolerance as a fraction of the expected value, but relative comparisons like that are even more difficult to write correctly and concisely. The ``approx`` class performs floating-point comparisons using a syntax that's as intuitive as possible:: >>> from pytest import approx >>> 0.1 + 0.2 == approx(0.3) True The same syntax also works for ordered sequences of numbers:: >>> (0.1 + 0.2, 0.2 + 0.4) == approx((0.3, 0.6)) True ``numpy`` arrays:: >>> import numpy as np # doctest: +SKIP >>> np.array([0.1, 0.2]) + np.array([0.2, 0.4]) == approx(np.array([0.3, 0.6])) # doctest: +SKIP True And for a ``numpy`` array against a scalar:: >>> import numpy as np # doctest: +SKIP >>> np.array([0.1, 0.2]) + np.array([0.2, 0.1]) == approx(0.3) # doctest: +SKIP True Only ordered sequences are supported, because ``approx`` needs to infer the relative position of the sequences without ambiguity. This means ``sets`` and other unordered sequences are not supported. Finally, dictionary *values* can also be compared:: >>> {'a': 0.1 + 0.2, 'b': 0.2 + 0.4} == approx({'a': 0.3, 'b': 0.6}) True The comparison will be true if both mappings have the same keys and their respective values match the expected tolerances. **Tolerances** By default, ``approx`` considers numbers within a relative tolerance of ``1e-6`` (i.e. one part in a million) of its expected value to be equal. This treatment would lead to surprising results if the expected value was ``0.0``, because nothing but ``0.0`` itself is relatively close to ``0.0``. To handle this case less surprisingly, ``approx`` also considers numbers within an absolute tolerance of ``1e-12`` of its expected value to be equal. Infinity and NaN are special cases. Infinity is only considered equal to itself, regardless of the relative tolerance. NaN is not considered equal to anything by default, but you can make it be equal to itself by setting the ``nan_ok`` argument to True. (This is meant to facilitate comparing arrays that use NaN to mean "no data".) Both the relative and absolute tolerances can be changed by passing arguments to the ``approx`` constructor:: >>> 1.0001 == approx(1) False >>> 1.0001 == approx(1, rel=1e-3) True >>> 1.0001 == approx(1, abs=1e-3) True If you specify ``abs`` but not ``rel``, the comparison will not consider the relative tolerance at all. In other words, two numbers that are within the default relative tolerance of ``1e-6`` will still be considered unequal if they exceed the specified absolute tolerance. If you specify both ``abs`` and ``rel``, the numbers will be considered equal if either tolerance is met:: >>> 1 + 1e-8 == approx(1) True >>> 1 + 1e-8 == approx(1, abs=1e-12) False >>> 1 + 1e-8 == approx(1, rel=1e-6, abs=1e-12) True You can also use ``approx`` to compare nonnumeric types, or dicts and sequences containing nonnumeric types, in which case it falls back to strict equality. This can be useful for comparing dicts and sequences that can contain optional values:: >>> {"required": 1.0000005, "optional": None} == approx({"required": 1, "optional": None}) True >>> [None, 1.0000005] == approx([None,1]) True >>> ["foo", 1.0000005] == approx([None,1]) False If you're thinking about using ``approx``, then you might want to know how it compares to other good ways of comparing floating-point numbers. All of these algorithms are based on relative and absolute tolerances and should agree for the most part, but they do have meaningful differences: - ``math.isclose(a, b, rel_tol=1e-9, abs_tol=0.0)``: True if the relative tolerance is met w.r.t. either ``a`` or ``b`` or if the absolute tolerance is met. Because the relative tolerance is calculated w.r.t. both ``a`` and ``b``, this test is symmetric (i.e. neither ``a`` nor ``b`` is a "reference value"). You have to specify an absolute tolerance if you want to compare to ``0.0`` because there is no tolerance by default. More information: :py:func:`math.isclose`. - ``numpy.isclose(a, b, rtol=1e-5, atol=1e-8)``: True if the difference between ``a`` and ``b`` is less that the sum of the relative tolerance w.r.t. ``b`` and the absolute tolerance. Because the relative tolerance is only calculated w.r.t. ``b``, this test is asymmetric and you can think of ``b`` as the reference value. Support for comparing sequences is provided by :py:func:`numpy.allclose`. More information: :std:doc:`numpy:reference/generated/numpy.isclose`. - ``unittest.TestCase.assertAlmostEqual(a, b)``: True if ``a`` and ``b`` are within an absolute tolerance of ``1e-7``. No relative tolerance is considered , so this function is not appropriate for very large or very small numbers. Also, it's only available in subclasses of ``unittest.TestCase`` and it's ugly because it doesn't follow PEP8. More information: :py:meth:`unittest.TestCase.assertAlmostEqual`. - ``a == pytest.approx(b, rel=1e-6, abs=1e-12)``: True if the relative tolerance is met w.r.t. ``b`` or if the absolute tolerance is met. Because the relative tolerance is only calculated w.r.t. ``b``, this test is asymmetric and you can think of ``b`` as the reference value. In the special case that you explicitly specify an absolute tolerance but not a relative tolerance, only the absolute tolerance is considered. .. note:: ``approx`` can handle numpy arrays, but we recommend the specialised test helpers in :std:doc:`numpy:reference/routines.testing` if you need support for comparisons, NaNs, or ULP-based tolerances. To match strings using regex, you can use `Matches `_ from the `re_assert package `_. .. warning:: .. versionchanged:: 3.2 In order to avoid inconsistent behavior, :py:exc:`TypeError` is raised for ``>``, ``>=``, ``<`` and ``<=`` comparisons. The example below illustrates the problem:: assert approx(0.1) > 0.1 + 1e-10 # calls approx(0.1).__gt__(0.1 + 1e-10) assert 0.1 + 1e-10 > approx(0.1) # calls approx(0.1).__lt__(0.1 + 1e-10) In the second example one expects ``approx(0.1).__le__(0.1 + 1e-10)`` to be called. But instead, ``approx(0.1).__lt__(0.1 + 1e-10)`` is used to comparison. This is because the call hierarchy of rich comparisons follows a fixed behavior. More information: :py:meth:`object.__ge__` .. versionchanged:: 3.7.1 ``approx`` raises ``TypeError`` when it encounters a dict value or sequence element of nonnumeric type. .. versionchanged:: 6.1.0 ``approx`` falls back to strict equality for nonnumeric types instead of raising ``TypeError``. Tz:pytest.approx() only supports ordered sequences, but got: )r\rr]rr_is_numpy_arrayrr{rxrrrfbytesrr^)r.r8r7r9r<clsrs r1approxrsJ(G$ - Hg &  ""8, 8 $  Hj )*XU|2TJ8,Wn xc6 **r>cpt|dxr)t|txrt|ttf S)N __getitem__)hasattrr\rrfr)r.s r1rxrxs6-( 3 x ' 38c5\2 2r>ct|duS)zr Return true if the given object is implicitly convertible to ndarray, and numpy is already imported. N)r)objs r1rrs 3 t ++r>cddl}|jjd}|S|j|ryt ||j r|St |ds t ddr|j|Sy)z Return an ndarray if the given object is implicitly convertible to ndarray, and numpy is already imported, otherwise None. rNr __array__r__array_interface__)sysmodulesgetrr\rrr)rrrs r1rrse kkoog&B ~ ;;s  RZZ (J S+ &'%9N*O::c? " r>E)bound.)matchcyr@rF)expected_exceptionrs r1raisesrs r>cyr@rF)rfuncargskwargss r1rrs &)r>cd}|std|dt|tr|f}n|}|D]o}t|trt|tr$d}t|tr |j nt|j }t |j|d|}|sP|jdd} |r/d}|d jt|z }|d z }t |t||| S|d } t| st | d t| d  | |ddi|t#|y#|$r3} tjjj!| cYd} ~ Sd} ~ wwxYw)aAssert that a code block/function call raises an exception type, or one of its subclasses. :param expected_exception: The expected exception type, or a tuple if one of multiple possible exception types are expected. Note that subclasses of the passed exceptions will also match. :kwparam str | re.Pattern[str] | None match: If specified, a string containing a regular expression, or a regular expression object, that is tested against the string representation of the exception and its :pep:`678` `__notes__` using :func:`re.search`. To match a literal string that may contain :ref:`special characters `, the pattern can first be escaped with :func:`re.escape`. (This is only used when ``pytest.raises`` is used as a context manager, and passed through to the function otherwise. When using ``pytest.raises`` as a function, you can use: ``pytest.raises(Exc, func, match="passed on").match("my pattern")``.) Use ``pytest.raises`` as a context manager, which will capture the exception of the given type, or any of its subclasses:: >>> import pytest >>> with pytest.raises(ZeroDivisionError): ... 1/0 If the code block does not raise the expected exception (:class:`ZeroDivisionError` in the example above), or no exception at all, the check will fail instead. You can also use the keyword argument ``match`` to assert that the exception matches a text or regex:: >>> with pytest.raises(ValueError, match='must be 0 or None'): ... raise ValueError("value must be 0 or None") >>> with pytest.raises(ValueError, match=r'must be \d+$'): ... raise ValueError("value must be 42") The ``match`` argument searches the formatted exception string, which includes any `PEP-678 `__ ``__notes__``: >>> with pytest.raises(ValueError, match=r"had a note added"): # doctest: +SKIP ... e = ValueError("value must be 42") ... e.add_note("had a note added") ... raise e The context manager produces an :class:`ExceptionInfo` object which can be used to inspect the details of the captured exception:: >>> with pytest.raises(ValueError) as exc_info: ... raise ValueError("value must be 42") >>> assert exc_info.type is ValueError >>> assert exc_info.value.args[0] == "value must be 42" .. warning:: Given that ``pytest.raises`` matches subclasses, be wary of using it to match :class:`Exception` like this:: with pytest.raises(Exception): # Careful, this will catch ANY exception raised. some_function() Because :class:`Exception` is the base class of almost all exceptions, it is easy for this to hide real bugs, where the user wrote this expecting a specific exception, but some other exception is being raised due to a bug introduced during a refactoring. Avoid using ``pytest.raises`` to catch :class:`Exception` unless certain that you really want to catch **any** exception raised. .. note:: When using ``pytest.raises`` as a context manager, it's worthwhile to note that normal context manager rules apply and that the exception raised *must* be the final line in the scope of the context manager. Lines of code after that, within the scope of the context manager will not be executed. For example:: >>> value = 15 >>> with pytest.raises(ValueError) as exc_info: ... if value > 10: ... raise ValueError("value must be <= 10") ... assert exc_info.type is ValueError # This will not execute. Instead, the following approach must be taken (note the difference in scope):: >>> with pytest.raises(ValueError) as exc_info: ... if value > 10: ... raise ValueError("value must be <= 10") ... >>> assert exc_info.type is ValueError **Using with** ``pytest.mark.parametrize`` When using :ref:`pytest.mark.parametrize ref` it is possible to parametrize tests such that some runs raise an exception and others do not. See :ref:`parametrizing_conditional_raising` for an example. .. seealso:: :ref:`assertraises` for more examples and detailed discussion. **Legacy form** It is possible to specify a callable by passing a to-be-called lambda:: >>> raises(ZeroDivisionError, lambda: 1/0) or you can specify an arbitrary callable with arguments:: >>> def f(x): return 1/x ... >>> raises(ZeroDivisionError, f, 0) >>> raises(ZeroDivisionError, f, x=0) The form above is fully supported but discouraged for new code because the context manager form is regarded as more readable and less error-prone. .. note:: Similar to caught exception objects in Python, explicitly clearing local references to returned ``ExceptionInfo`` objects can help the Python interpreter speed up its garbage collection. Clearing those references breaks a reference cycle (``ExceptionInfo`` --> caught exception --> frame stack raising the exception --> current frame stack --> local variables --> ``ExceptionInfo``) which makes Python keep all objects referenced from that cycle (including all local variables in the current frame) alive until the next cyclic garbage collection run. More detailed information can be found in the official Python documentation for :ref:`the try statement `. TzCExpected an exception type or a tuple of exception types, but got `z`. Raising exceptions is already understood as failing the test, so you don't need any special code to say 'this should never raise an exception'.z7expected exception must be a BaseException type, not {}zDID NOT RAISE rNz6Unexpected keyword arguments passed to pytest.raises: z, z" Use context-manager form instead?rz object (type: z) must be callabler)rr\rw issubclass BaseExceptionrjrrpopjoinsorted RaisesContextcallable_pytest_code ExceptionInfofrom_exceptionr) rrrr<expected_exceptionsexcrnot_amessagerrrs r1rr"sZ QRdQghN O  $d+4F3H0"#t$JsM,JKC$.sD$9CLLtCy?Q?QECJJu-. . # 123G +1::gt+D JC 499VF^, ,C 8 8CC. /%@@Aw~thod4j\ASTU U A $qr( %f % M" A==..==a@ @ As D77E/<(E*$E/*E/cFeZdZ d ddZddZ ddZy) rNc||_||_||_d|_|j4d} t j |j|td|yyy#tj $r }|}Yd}~-d}~wwxYw)Nz+Invalid regex pattern provided to 'match': )rr match_exprexcinforecompileerrorr)r;rrrre_errorrs r1r=zRaisesContext.__init__s #5 $>B ?? &H  4??+#B8*MN$ '88  sAA=1A88A=cttjjj|_|jSr@)rrr  for_laterrrCs r1 __enter__zRaisesContext.__enter__s&}}22<<> ||r>cpd}|t|j|jJt||jsyt t ttttf|||f}|jj||j%|jj|jy)NTF) rrrrrr rrrr fill_unfilledrr)r;exc_typeexc_valexc_tbr<exc_infos r1__exit__zRaisesContext.__exit__s !    ||'''(D$;$;<d1gq-788Wf:UV ""8, ?? & LL  t /r>r@)rtype[E] | tuple[type[E], ...]rrfrstr | Pattern[str] | Nonercrd)rc_pytest._code.ExceptionInfo[E])rztype[BaseException] | NonerzBaseException | NonerzTracebackType | Nonercrb)rjrkrlr=rr rFr>r1rrsg 15 O9OO. O  O&,&%   r>r)r$objectr%zSequence[tuple[str, str, str]]r&intr'zSequence[object]r(floatr)r&rcrgra)r9rbrcr4)r.r$rcrb)rr$rcrb)rr$rczndarray | None)rr!rr"rczRaisesContext[E]) rr!rzCallable[..., Any]rr rr rcr#)rr!rr rr rcz1RaisesContext[E] | _pytest._code.ExceptionInfo[E])5 __future__rcollections.abcrrdecimalrrnumbersrrrtypesrtypingr r r r r rrrrrrrr _pytest._coder_pytest.outcomesrrrr2r4rsr{rrr^r]rrxrrrrrrrr rrFr>r1r/s"&!  ! !0$     :8K8K@e@*e@PIWJIWXBUBUJC;:C;L1L1V+r,* C}% (+5 %   )5) ) ) ) $ ) )q5q>AqMPq6qj>>)N7==#>#>q#AB))r>