|fd? Z8e!de j9 j: e7 f fdDZ8e#j; e8_; e G dE dFee j9 j: e7 Zz#_compare_approx..> ss 'GXx ^Yq\^^^^x^)A,^^^^H^yYZ|^^^^ r% )listinsertmaxlen) r& r' r( r) r* r+ message_listindexr8 r9 explanationr: s @r# _compare_approxrC + s %%L<=== I%1 8 8!x9Q<U44 ! 9Q<X 77 ! 9Q<X 77 ! _3}3E3E__J\___2L222L22 +7 K r% c e Zd ZdZdZdZddeddfdZdefdZ d e
de e fd
Z defd Z
d ZdZdefd
ZddZd ZddZdS )
ApproxBasezhProvide shared utilities for making approximate comparisons between
numbers or sequences of numbers.Nd Fnan_okr c j d}|| _ || _ || _ || _ | d S )NT)r9 absrelrG _check_type)selfr9 rJ rI rG __tracebackhide__s r# __init__zApproxBase.__init__P s<
r% c t NNotImplementedErrorrL s r# __repr__zApproxBase.__repr__X s !!r%
other_sidec dd| d| gS )Nzcomparison failedz
Obtained: z
Expected: r5 )rL rU s r#
_repr_comparezApproxBase._repr_compare[ s% % % %
r% c ` t fd | D S )Nc 3 P K | ] \ }}| | k V !d S rP _approx_scalar)r6 axrL s r# z$ApproxBase.__eq__..c sK
,0AqA$$Q'' '
r% )all_yield_comparisonsrL actuals ` r# __eq__zApproxBase.__eq__b sI
484K4KF4S4S
r% c $ d}t d )NTzVapprox() is not supported in a boolean context.
Did you mean: `assert a == approx(b)`?)AssertionError)rL rM s r# __bool__zApproxBase.__bool__g s e
r% c || k S rP r5 ra s r# __ne__zApproxBase.__ne__p s dN##r% ApproxScalarc t |t r"t || j | j | j S t
|| j | j | j S )N)rJ rI rG )
isinstancer
ApproxDecimalrJ rI rG ri )rL r] s r# r[ zApproxBase._approx_scalars sO a ! ! T dht{SSS SA48$+NNNNr% c t )zoYield all the pairs of numbers to be compared.
This is used to implement the `__eq__` method.
rQ ra s r# r` z ApproxBase._yield_comparisonsx s
"!r% c dS )z. s. CC2/266CCCCCCr% )rk r< tupletype)r~ r] seq_types ` r# r| r| sV !dE]## 77xCCCCCCCCCCqtt r% c V e Zd ZdZdefdZdddee fdZdef fd Z d Z
xZ S ) ApproxNumpyzHPerform approximate comparisons where the expected value is numpy array.r c f t | j | j }d|dS )Nzapprox())r| r[ r9 tolist)rL list_scalarss r# rT zApproxNumpy.__repr__ s: . !5!5!7!7
+ ****r% rU r c dd l }dd l}dt t dt t df dt fd| j j }t | j | j |j k rdd| d j gS | j j
}|j }|j }g } |j d
|D D ]} | }
| } |
| k rjt |
j | z
} t || }| d k r|j }n t || t | z }| | fd |D }
t! | j |
|||| S )
Nr nested_listnd_index.r c $ | }|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.
r5 )r r r! is r# get_value_from_nested_listz=ApproxNumpy._repr_compare..get_value_from_nested_list s( %E
!
! aLr% z3Impossible to compare arrays with different shapes.zShapes: and c 3 4 K | ]}t | V d S rP )range)r6 r s r# r^ z,ApproxNumpy._repr_compare.. s( (J(Jaq(J(J(J(J(J(Jr% c
g | ]B}t | t | t | fCS r5 rx )r6 rA approx_side_as_seqr rU s r# r; z-ApproxNumpy._repr_compare.. si
E
..z5AABB../A5IIJJ
r% ) itertoolsmathr r r r9 shaper| r[ r sizeinfproductrI r> appendrC )rL rU r r np_array_shaper( r* r+ r) rA approx_value other_valueabs_diffr' r r s ` @@r# rW zApproxNumpy._repr_compare s
c
.3CHo
, 4 !5!5!7!7
Z - - -EB>BB
0@BB
"] / y y
&Y&(J(J>(J(J(JK
,
,E556H%PPL44ZGGK{** | 4{ BCC "< : : #%%#'8LL#&|XK@P@P5P#Q#QL $$U+++
'
M
r% c J dd l }| | s= | | }n&# t $ r}t d| d |d }~ww xY w| | s|j | j j k rdS t | S )Nr zcannot compare 'z' to numpy.ndarrayF) numpyisscalarasarray Exceptionr r r9 superrc )rL rb npe __class__s r# rc zApproxNumpy.__eq__ s {{6"" V
VF++
V
V
V M6 M M MNNTUU
V {{6"" v|t}7J'J'J5ww~~f%%%s 2
AAAc # K dd l }| | rG| | j j D ]%}|| j | fV &d S | | j j D ]=}|| | j | fV >d S )Nr )r r ndindexr9 r item)rL rb r r s r# r` z ApproxNumpy._yield_comparisons s ;;v @ZZ
344
6
6 dmA . 3 3 5 555555
6
6 ZZ
344
@
@ Qinn&&
a(8(=(=(?(??????
@
@r% ) rq rr rs rt rx rT r rW rw rc r`
__classcell__r s @r# r r s RR+# + + + + :
:
d3i :
:
:
:
x& & & & & & & @ @ @ @ @ @ @r% r c n e Zd ZdZdefdZdeeef de e fdZ
de f fd Z d Z
d
d Z xZS )
ApproxMappingzyPerform approximate comparisons where the expected value is a mapping
with numeric values (the keys can be anything).r c t d fd j D S )N approx({!r})c B i | ]\ }}| | S r5 rZ r6 kvrL s r#
z*ApproxMapping.__repr__.. s- I I I41aQ##A&& I I Ir% )r r9 itemsrS s `r# rT zApproxMapping.__repr__ s@ $$ I I I I4=3F3F3H3H I I I
r% rU c f dd l } fd j D t }|j }|j }g }t D ]\ \ }}} || k rzt |t |j | z
}|j dk r|j }n-t |t |j | z
|j z }| | fd|D }
t j |
|||| S )Nr c B i | ]\ }}| | S r5 rZ r s r# r z/ApproxMapping._repr_compare.. s:
*.!QAt""1%%
r% r c g | ]:}t | t | t | f;S r5 r )r6 keyapprox_side_as_maprU s r# r; z/ApproxMapping._repr_compare.. sP
XXs:c?++S1CC1H-I-I J
r% ) r r9 r r? r zipvaluesr> rI r rC ) rL rU r r( r* r+ r)
approx_keyr r r' r s `` @r# rW zApproxMapping._repr_compare s
26-2E2E2G2G
!!3 4 4 y y
7: $ $ & &
(9(9(;(;8
8
1 1 3 &Z {** " #l&;k&I"J"J (C//#'8LL#&$ ) 2[ @ * 3 4 $ $L $$Z000
$
M
r% c t | t | j k rdS n# t $ r Y dS w xY wt | S NF)setkeysr9 AttributeErrorr rc rL rb r s r# rc zApproxMapping.__eq__* s} 6;;==!!S ););)=)=%>%>>> u ? 55 ww~~f%%%s A A
A A c # p K | j D ]}|| | j | fV d S rP )r9 r )rL rb r s r# r` z ApproxMapping._yield_comparisons3 sL ##%% . .A)T]1 -- - - - - . .r% Nc
d}| j D ]d\ }}t |t | j r=d}t | ||t
j | j ed S )NTz[pytest.approx() does not support nested dictionaries: key={!r} value={!r}
full mapping={})r9 r rk r r r pprintpformat)rL rM r r! msgs r# rK zApproxMapping._check_type7 s ---// W WJC%dm!4!455
Wt
3v~dm7T7T U UVVV
W W Wr% rp )rq rr rs rt rx rT r
objectfloatr rW rw rc r` rK r r s @r# r r s 7 7
#
*
(> *
49 *
*
*
*
X& & & & & & &. . .W W W W W W W Wr% r c j e Zd ZdZdefdZdee dee fdZ de
f fd Z d Z d
d Z
xZS ) ApproxSequenceLikezRPerform approximate comparisons where the expected value is a sequence of numbers.r c t j }|t t fvrt }d | fd j D S )Nr c 3 B K | ]} | V d S rP rZ )r6 r] rL s r# r^ z.ApproxSequenceLike.__repr__..G s1 CCT((++CCCCCCr% )r r9 r r< r )rL r s ` r# rT zApproxSequenceLike.__repr__B sb
&& E4= ( (H $$ HCCCCT]CCC C C
r% rU c dd l }t | j t k r)ddt | j dt gS t | j | j t }|j }|j }g }t
t D ]x\ }\ }} || k rjt |j | z
}
t ||
}| dk r|j }n t ||
t | z }|
| y fd|D } t | j | |||| S )Nr z1Impossible to compare lists with different sizes.z Lengths: r r c g | ]:}t | t | t | f;S r5 r )r6 r r rU s r# r; z4ApproxSequenceLike._repr_compare..e sP
VVSA ''-?-B)C)C D
r% ) r r? r9 r| r[ r enumerater rI r> r rC )
rL rU r r( r* r+ r) r r r r r' r s
` @r# rW z ApproxSequenceLike._repr_compareJ s t} Z 0 0CFC
. .FFS__FF
5T5H$- X X !3 4 4 y y
.7 "J / //
/
(
( *A* k {** | 4{ BCC "< : : #%%#'8LL#&|XK@P@P5P#Q#QL $$Q'''
"
M
r% c t | t | j k rdS n# t $ r Y dS w xY wt | S r )r? r9 r r rc r s r# rc zApproxSequenceLike.__eq__s se 6{{c$- 0 000 u 1 55 ww~~f%%%s %+
99c , t || j S rP )r r9 ra s r# r` z%ApproxSequenceLike._yield_comparisons{ s 64=)))r% Nc
d}t | j D ]d\ }}t |t | j r=d}t | ||t
j | j ed S )NTz]pytest.approx() does not support nested data structures: {!r} at index {}
full sequence: {})r r9 rk r r r r r )rL rM rA r] r s r# rK z ApproxSequenceLike._check_type~ s !$-00 U UHE1!T$- 0 011
Uv
1eV^DM5R5R S STTT
U U Ur% rp )rq rr rs rt rx rT r r r rW rw rc r` rK r r s @r# r r ? s \\
#
'
'
DI '
'
'
'
R& & & & & & &* * *U U U U U U U Ur% r c e Zd ZU dZdZeeef ed< dZ eeef ed< de
fdZ de fdZ
d Zed
Zd S ) ri zLPerform approximate comparisons where the expected value is a single number.g-q=DEFAULT_ABSOLUTE_TOLERANCEgư>DEFAULT_RELATIVE_TOLERANCEr c t | j t t f r&t j t
| j rt | j S | j d}t | j t r*| j j r t j | j s|dz
}n# t $ r d}Y nw xY w| j d| S )u Return 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 ± ) rk r9 r r r isinfrI rx toleranceimag
ValueError)rL vetted_tolerances r# rT zApproxScalar.__repr__ s 4=7G*<== &$*
C
C
& t}%% % %"&. 6 6 4='22
3M&
3
4>22
3
!N2 % % % $ % -77%5777s A
B+ + B:9B:c . t | }| t fd|j D S | j k rdS t j t
t f r t |t
t f sdS t j t j r( j
o t j t | S t j t j rdS t j |z
j k }|S )ziReturn whether the given value is equal to the expected value
within the pre-specified tolerance.Nc 3 B K | ]} | V d S rP )rc )r6 r\ rL s r# r^ z&ApproxScalar.__eq__.. s- <.set_default s
117 2r% r z&absolute tolerance can't be negative: z absolute tolerance can't be NaN.Nz&relative tolerance can't be negative: z relative tolerance can't be NaN.) rI r r r r rJ r r9 r> )rL r absolute_tolerancerelative_tolerances r# r zApproxScalar.tolerance s$ 3 3 3
)[43R S S ! ! M9KMM
:( ) ) A ?@@ @ 8 x#)) )[ Hd5
! ! M9KMM
:( ) ) A ?@@ @ %'9:::r% )rq rr rs rt r r r r __annotations__r rx rT rw rc ry propertyr r5 r% r# ri ri s VV 9> eWn 5===8< eWn 5<<<8# 8 8 8 8:' ' ' ' 'T H
,; ,; X,; ,; ,;r% ri c > e Zd ZdZ ed Z ed ZdS )rl zFPerform approximate comparisons where the expected value is a Decimal.z1e-12z1e-6N)rq rr rs rt r r r r5 r% r# rl rl s4 PP!(!1!1 !( r% rl FrG c
d}t | t rt }nt | t rt }nt | rt
| } t }nt | d r2t | t r t | t st }nRt | t r6t | t s!dt | }t | t } || ||| S )a Assert that two numbers (or two ordered sequences of numbers) are equal to each other
within some tolerance.
Due to the :doc:`python:tutorial/floatingpoint`, numbers that we
would intuitively expect to be equal are not always so::
>>> 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``.
T __getitem__z:pytest.approx() only supports ordered sequences, but got: )rk r rl r
r _is_numpy_arrayr r hasattrr r r r reprr ri )r9 rJ rI rG rM clsr s r# approxr s L (G$$ - Hg & & " " "8,,-(( x ' ' 8\22 !8Z(( 8\22
\4PX>>[[nn 3xc6 * **r% objc $ t | duS )zr
Return true if the given object is implicitly convertible to ndarray,
and numpy is already imported.
N)r )r s r# r r s
3 t ++r% r c ddl }|j d }|c| | rdS t | |j r| S t
| d st
dd r| | S dS )z
Return an ndarray if the given object is implicitly convertible to ndarray,
and numpy is already imported, otherwise None.
r Nr __array__r __array_interface__)sysmodulesgetr rk r r r )r r r s r# r r s
JJJkoog&&B ~
;;s #4
RZ
(
( #J
S+
&
& #'%9N*O*O #::c?? " 4r% E)bound.)matchexpected_exceptionr zRaisesContext[E]c d S rP r5 )r r s r# raisesr s Cr% funcargskwargsc d S rP r5 )r r r r s r# r r s Cr% c f d}| st d| d t | t r| f}n| }|D ]}t |t rt |t sTd}t |t r|j nt | j }t
| | d| }|sd| dd } |r;d}|d t | z
}|d
z
}t
| t | || S |d }
t |
s"t
|
d t |
d
|
|dd i | n6# | $ r.} t j j | cY d} ~ S d} ~ ww xY wt# | dS )a8 Assert that a code block/function call raises an exception.
:param typing.Type[E] | typing.Tuple[typing.Type[E], ...] expected_exception:
The expected exception type, or a tuple if one of multiple possible
exception types are expected.
:kwparam str | typing.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 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 :py:func:`pytest.raises` is used as a context manager,
and passed through to the function otherwise.
When using :py:func:`pytest.raises` as a function, you can use:
``pytest.raises(Exc, func, match="passed on").match("my pattern")``.)
.. currentmodule:: _pytest._code
Use ``pytest.raises`` as a context manager, which will capture the exception of the given
type::
>>> import pytest
>>> with pytest.raises(ZeroDivisionError):
... 1/0
If the code block does not raise the expected exception (``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 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"
.. 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.
**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 r Nz6Unexpected keyword arguments passed to pytest.raises: z, z"
Use context-manager form instead?r z object (type: z) must be callabler0 )r rk r
issubclass
BaseExceptionrq r r popjoinsorted
RaisesContextcallable_pytest_code
ExceptionInfofrom_exceptionr ) r r r rM expected_exceptionsexcr not_amessager r r s r# r r $ s d
ORd
O
O
O
$d++ 14F3H 0" / /#t$$ /JsM,J,J /KC$.sD$9$9QCLLtCyy?QECJJu - -.. . /
4 133G A4:JJw4M4M !JC 499VF^^,, ,C 8 8CC.. /%@@@Aw~~ Vt T Td4jj T T TUU U A D$qrr( %f % % % %! A A A=.==a@@ @ @ @ @ @ @ AMMMMMs E, ,F 1#FF F c e Zd Z d
deee eee df f dedeeee e f ddfdZ
de j j
e fdZd eee d
ee d ee defd ZdS )r Nr .r
match_exprr c > || _ || _ || _ d | _ d S rP )r r r excinfo)rL r r r s r# rN zRaisesContext.__init__ s% #5 $AE r% c ` t j j | _ | j S rP )r r r for_laterr rS s r# __enter__zRaisesContext.__enter__ s" }2<<>> |r% exc_typeexc_valexc_tbc l d}|t | j | j J t || j sdS t t t t t t f |||f }| j
| | j | j | j dS )NTF)
r r r r r r
r r r r
fill_unfilledr r )rL r r r! rM exc_infos r# __exit__zRaisesContext.__exit__ s ! |'''(D$;<< 5d1gq- 788Wf:UVV ""8,,, ? & L t / / /tr% rP )rq rr rs r r r r rx r r rN r r r r r
r rw r% r5 r% r# r r s :> F F !$q'5a# +>"> ? F F U3 #4 56 F
F F F F 7=6q9 4
./ -( '
r% r ro )=r r collections.abcr r decimalr numbersr typesr typingr r r
r r r
r r r r r r r r r r
_pytest._coder _pytest.compatr r r _pytest.outcomesr rx r r$ r intr rC rE r| r r r ri rl rw r r r r
r r r r r r r5 r% r# r/ s
& & & & & & ! ! ! ! ! ! ! ! ! ! ! ! ' ' ' ' ' ' # # # # # # ! ! ! ! ! !x} 5c3 /0 F#
#Y :8K 8K 8K 8K 8K 8K 8K 8K@ a@ a@ a@ a@ a@* a@ a@ a@HGW GW GW GW GWJ GW GW GWTDU DU DU DU DU DU DU DUN~; ~; ~; ~; ~;: ~; ~; ~;B1 1 1 1 1L 1 1 1`+ `+ `+* `+ `+ `+ `+F, ,D , , , , HY$7 * GC}%%%
14 d1guT!Wc\': :; E#ws|+, -
d1guT!Wc\': :;
38
] #
V d1guT!Wc\': :;VDGVSVV
w} :1 = =>V V V Vt > ! ! ! ! !N7=#>q#AB ! ! ! ! !r%