^Yc@`s"dZddlmZmZmZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl Z ddlmZddlmZddlZddljZddlmZddlmZdd lmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(e j)j*ej+j,d Z-e j)j*ej+j.Z/e j)j*e j+j.Z0d Z1d Z2dZ3dZ4dZ5dZ6ede7dZ8dZ9dZ:ede7dZ;ddZ=de>fdYZ?de?fdYZ@de@ejAfdYZBdZCd ZDd!ejEeBfd"YZFdd#ZGd$ZHd%eBfd&YZId'eBfd(YZJd)e@fd*YZKd+eKeBfd,YZLd-ZMd.ZNd/e>fd0YZOd1ejPfd2YZQd3ZRdd4ZSdd5ZTdddd6ZUd7ZVd8ZWd9ZXd:ZYd;ZZe(j[eZ_[d<e>fd=YZ\d>e>fd?YZ]d@e>fdAYZ^dBeKej_ejPfdCYZ`dS(Ds9 Python test discovery, setup and run of test functions. i(tabsolute_importtdivisiontprint_functionN(tcount(t MarkerError(thookimpl(tfixtures(tmain(tisclasst isfunctiont is_generatort_escape_stringst REGEX_TYPEt STRING_TYPEStNoneTypetNOTSETt get_real_funct getfslinenot safe_getattrtsafe_strt getlocationtenum(tfailtoccC`ss|jjjj}d|ko'd|k}|r4tStjj|j}|tkor|j t  or|j t  S(sReturn True if a TracebackEntry instance should be removed from tracebacks: * dynamically generated code (no code to show up for it); * internal traceback from pytest or its internal libraries, py and pluggy. t( tframetcodetrawt co_filenametFalsetpytpathtlocaltcutdir1treltotcutdir2tcutdir3(tentryt raw_filenamet is_generatedtp((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytfilter_traceback!s c`s5fd}djf}t|dd|S(Nc`s5|jttd}|dk r1|jSdS(Ntpytest(t getparenttgetattrt __import__tNonetobj(tselftnode(tname(s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytget5s s<python %s object this node was collected from (can be None).(tlowertpropertyR/(R3R4tdoc((R3s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytpyobj_property4sc C`s|jd}|jdddddddtd d |jd dddd dtd d |jddddgd d|jddddddgd d|jdddddgd d|jdddddgd d|jddddddgdd d d!dS("Ntgenerals --fixturess --funcargstactiont store_truetdestt showfixturestdefaultthelps4show available fixtures, sorted by plugin appearances--fixtures-per-testtshow_fixtures_per_testsshow fixtures per testt usefixturesttypetargss5list of default fixtures to be used with this projectt python_filess test_*.pys *_test.pys9glob-style file patterns for Python test module discoverytpython_classestTests6prefixes or glob names for Python test class discoverytpython_functionsttestsDprefixes or glob names for Python test function and method discoverys --import-modetprependtchoicestappendt importmodesNprepend/append to sys.path when importing test modules, default is to prepend.(tgetgroupt addoptionRtaddini(tparsertgroup((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytpytest_addoption>s, cC`s8|jjrt|dS|jjr4t|dSdS(Ni(toptionR=R@(tconfig((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytpytest_cmdline_main[s     cC`sdddg}xG|D]?}t|j|rd}t|j|jj|qqWy|jj}Wntk r}dSXx$|D]}|j|j|jqWdS(Nt parameterizet parametriset parameterises/{0} has '{1}', spelling should be 'parametrize'( thasattrtfunctionRtformatt__name__t parametrizetAttributeErrorRCtkwargs(tmetafunct alt_spellingstattrtmsgtmarkerstmarker((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytpytest_generate_testsds %  cC`s$|jdd|jdddS(NRdsparametrize(argnames, argvalues): call a test function multiple times passing in different arguments in turn. argvalues generally needs to be a list of values if argnames specifies only one name or a list of tuples of values if argnames specifies multiple names. Example: @parametrize('arg1', [1,2]) would lead to two calls of the decorated test function, one with arg1=1 and another with arg1=2.see http://pytest.org/latest/parametrize.html for more info and examples.susefixtures(fixturename1, fixturename2, ...): mark tests as needing all of the specified fixtures. see http://pytest.org/latest/fixture.html#usefixtures (taddinivalue_line(RT((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytpytest_configuress  ttrylastcC`sg|j}|jr%||jn>|j}i}x"|jjD]}||||q#n|j}t|trtjj|d}|r|r|j |nPqn|j |q#W|jdj |}|j ddS(s7 return python path relative to the containing module. it.s.[t[( t listchaintreverset isinstanceRR3RtosR tsplitextRKtjointreplace(R1t stopatmodulet includemoduletchaintpartsR2R3ts((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt getmodpaths"     cC`s t|jS(N(RR0(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt _getfslinenoscC`s|j}t|dd}t|trbtj|jj}|j drY|d }n|}nt |\}}|j }t|tst |||fS(Ntcompat_co_firstlinenos.pyci( R0R-R/RtinttsystmodulesRt__file__tendswithRRtAssertionError(R1R0Rtfspathtlinenotmodpath((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt reportinfos    ( R\RR0RRoRRRR(((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs    t PyCollectorcB`sYeZdZdZdZdZdZdZdZdZ dZ RS( cC`s|jd|S(NRG(t_matches_prefix_or_glob_option(R1R3((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytfuncnamefilterscC`st|dttkS(sg Look for the __test__ attribute, which is applied by the @nose.tools.istest decorator R(RRRo(R1R0((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt isnosetestscC`s|jd|S(NRE(R(R1R3((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytclassnamefilterscC`sC|j|s|j|oBt|dtoBtj|dkS(Nt__call__(RRRRRtgetfixturemarkerR/(R1R0R3((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRscC`s|j|p|j|S(N(RR(R1R0R3((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRscC`snxg|jj|D]S}|j|r,tSd|ksPd|ksPd|krtj||rtSqWtS(ss checks if the given name matches the prefix or glob-pattern defined in ini configuration. t*t?R(RTRyt startswithRoRzR(R1t option_nameR3RS((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs$c C`s t|jdtsgSt|jdig}x-tj|jjD]}|j|jqGWi}g}x|D]}xt|j D]t\}}||krqnt||<|j ||}|dkrqnt |ts|g}n|j |qWqtW|jdd|S(NRt__dict__tkeycS`s|jd S(Ni(R(titem((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt@s(R-R0Rotinspecttgetmrot __class__RKRRtitemstmakeitemR/Rtextendtsort( R1tdictstbaseclstseentltdicR3R0R((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytcollect*s(     cC`s|jjd|d|d|S(NRR3R0(R~R(R1R3R0((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRCs c c`s|jtj}|jt}|r0|jp3d}t||||jj}|j|||}t |||j d|d|}g} t |dr| j |j nt |dr| j |j n| r|jj j| td|n|jj d||jd} |jsB| |d|d|Vnvtj|||x`|jD]U} d|| jf} | d | d|d | d |d|d it| j6d |Vq_WdS(NRRRfR`tFunctionRut fixtureinfos%s[%s]R3tcallspectcallobjtkeywordst originalname(R,RR0RR/ttransfer_markersRwt_fixturemanagertgetfixtureinfotMetafuncRTRYRKRfR~t call_extratdictRt_callsRtadd_funcarg_pseudo_fixture_deftidRo( R1R3tfuncobjRtclscolRtfmRR`tmethodsRRtsubname((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRHs8   ( R\RRRRRRRRRR(((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs       cC`sMyt||j}Wntk r*tSX|j|jkoL|j|jkS(s Returns True if :func: is already marked with :mark:, False otherwise. This can happen if marker is applied to class and the test file is invoked more than once. (R-R3R^RRCR_(tfunctmarkt func_mark((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt_markedms  cC`sx||fD]}y |j}Wntk r6q nXt|trvxI|D]"}t||sM||qMqMWq t||s ||q q WdS(N(t pytestmarkR^RRR(RRtmodtholderRR((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRys   RcB`s2eZdZdZdZdZdZRS(s+ Collector for test classes and functions. cC`s |jS(N(t_importtestmodule(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRscC`s&|jjj|tt|jS(N(RwRtparsefactoriestsuperRR(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRscC`s|jjd}y|jjd|}WnWtk rb|jtjjj ddn#|jj k rt j d}|jd|j ntk rNddlm}|}|jjd d kr|jjt|_n|jr|j ddn |j}t|}|jd jd |jd |n7tjjk r}|jrrn|jdnX|jjj||S(Ns --import-modet ensuresyspathtstyletshortisimport file mismatch: imported module %r has this __file__ attribute: %s which is not the same as the test file we want to collect: %s HINT: remove __pycache__ / .pyc files and/or use a unique basename for your test file modulesi(t ExceptionInfotverboseisImportError while importing test module '{fspath}'. Hint: make sure your test modules/packages have valid Python names. Traceback: {traceback}Rt tracebacksUsing pytest.skip outside of a test is not allowed. If you are trying to decorate a test function, use the @pytest.mark.skip or @pytest.mark.skipif decorators instead.(RTt getoptionRtpyimportt SyntaxErrort CollectErrort_pytestt_codeRtgetreprtImportMismatchErrorRtexc_infoRCt ImportErrort_pytest._code.codeRtfilterR*texconlyRR[trunnertSkippedtallow_module_levelt pluginmanagertconsider_module(R1RLRteRRtexc_reprt formatted_tb((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs8 !  '    cC`st|jd}|dkr3t|jd}n|dk rI|nt|jd}|dkr|t|jd}n|dk r|j|ndS(Nt setUpModulet setup_modulettearDownModuletteardown_module(t_get_xunit_setup_teardownR0R/t addfinalizer(R1RR((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytsetups     (R\Rt__doc__RRRR(((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs    ,c`s|dk rn|t||dk rxjj}tjr[|d8}n|rqfdSSndS(s^ Return a callable to perform xunit-style setup or teardown if the function exists in the ``holder`` object. The ``param_obj`` parameter is the parameter which will be passed to the function when the callable is called without arguments, defaults to the ``holder`` object. Return ``None`` if a suitable callable is not found. ic`s S(N(((t param_objtresult(s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRsN(R/t_get_xunit_funct__code__t co_argcountRtismethod(Rt attr_nameRt arg_count((RRs./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs   cC`s/t||d}tj|dkr+|SdS(sReturn the attribute from the given object to be used as a setup/teardown xunit-style function, but only if not marked as a fixture to avoid calling it twice. N(R-R/RR(R0R3tmeth((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRsRcB`s eZdZdZdZRS(s Collector for test methods. cC`st|jdtsgSt|jrF|jdd|jjgSt|jrs|jdd|jjgS|jdddd|gS( NRtC1sBcannot collect test class %r because it has a __init__ constructorsAcannot collect test class %r because it has a __new__ constructorRR3s()Ru(RR0RothasinitRR\thasnewR(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs  c`stjd}|dk rRt|d|}t|d|}|jntjdddk rtdtdjfdndS(Nt setup_classtim_funcRtteardown_classc`s jS(N(R0((t fin_classR1(s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs(RR0R/R-R(R1R'((R*R1s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs  (R\RRRR(((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs RcB`s#eZdZdZdZRS(cC`s |jjS(N(RuR0(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyR scC`s&|jjj|tt|jS(N(RwRRRRR(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyR scC`s|j|_|jS(N(RR0(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt newinstances(R\RRRR+(((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs  t FunctionMixincB`s8eZdZdZdZddZddZRS(s: mixin for the code common to Function and Generator. cC`st|dr|j}n?t|jtrN|jj}|j|_n |jj}tj |jr{d}d}n d}d}t ||d|j}|dk r|nt ||d|j}|dk r|j |ndS(s' perform setup for this test function. t_preservedparentt setup_methodtteardown_methodtsetup_functiontteardown_functionRN( RYR-RRuRR+RR0RR RR/R(R1R0t setup_namet teardown_nametsetup_func_or_methodtteardown_func_or_method((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs"      cC`s*t|dr&|jjj r&tjjt|j}|j |j }}|j }|j d|d|}||kr|j d|}||kr|j t}|s|}qqn|j |_ |jjjdkr&t|j dkr#x(|j dd!D]}|jdqWq#q&ndS( NRR t firstlinenotautoiiiR(RYRTRSt fulltraceRRtCodeRR0R R6RtcutR R*ttbstyletlentset_repr_style(R1texcinfoRR R6Rt ntracebackR&((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt_prunetraceback.s    tlongcC`sP|jtjr4|jjs4tjj|jSntt |j |d|S(NR( t errisinstanceRt ExceptionRtpytraceRt_builtint_totextRR,t_repr_failure_py(R1R>R((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRGDs  cC`sO|dkstd|jjj}|dkr<d}n|j|d|S(NsXXX outerr usage is deprecatedR7RAR(R/RRTRSR;RG(R1R>touterrR((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt repr_failureKs   N(R\RRRR@RGR/RI(((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyR,s    RcB`seZdZdZRS(c C`s;ddlm}|jjj||jj|_g}i}xt|jD]\}}|j |\}}}t |st d|j|fn|dkrd|}n d|}||krt d||fnt||<|j|j||d|d||jjd |jd |jqQW|S( Ni(t deprecateds%r yielded non callable test %rs[%d]s['%s']s*%r generated tests with non-unique name %rRCRR$t fslocation(RRJRwt _setupstatetprepareRuR0R-t enumeratet getcallargstcallablet TypeErrorR/t ValueErrorRoRKRRTRt YIELD_TESTSR( R1RJRRtitxR3tcallRC((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRTs$      %#cC`syt|ttfs!|f}nt|dtjjrQ|d}|d}nd}|d|d}}|||fS(Nii(RttupleRRtbuiltint _basestringR/(R1R0R3RVRC((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyROms   (R\RRRO(((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRSs cC`s)t|dd}|r%|tjkSdS(Nt__init__(R-R/tobjectRZ(R0tinit((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyR%zscC`s)t|dd}|r%|tjkSdS(Nt__new__(R-R/R[R](R0tnew((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyR&st CallSpec2cB`sMeZdZdZdZdZedZdZdZ RS(cC`sa||_i|_g|_i|_t|_t|_t|_i|_ i|_ i|_ dS(N( R`Rlt_idlisttparamsRt _globalidtsett_globalid_argst _globalparamt _arg2scopenumRtindices(R1R`((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRZs         cC`st|j}|jj|j|jj|j|jj|j|jj|j|jj|jt|j |_ |j |_ |j |_ |j |_ |S(N( R_R`RltupdateRaRRgRfRR`RbRdRe(R1R`tcs((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytcopys   cC`s8||jks||jkr4td|fndS(Ns duplicate %r(RaRlRR(R1Rs((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt_checkargnotcontainedscC`sIy|j|SWn3tk rD|jtkr=t|n|jSXdS(N(RatKeyErrorReRRR(R1R3((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytgetparams  cC`s"djtttd|jS(Nt-(RtmaptstrR R/R`(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRsc C`sxat||D]P\}} |j|||} | t|| |<||j|<||j|n|dkrd| |f}n| }|j|dtt| j|} | jjpd }|rYxQ|jjd D]}|jd |jq5Wq>|jd | fd tq>WdS(NiRs_pytest.Rnsfixtures defined from %sRs%s -- %sRts s s %s: no docstring availableR(RRRR R!RTRRRRcRRR/RRRRRRKR<tbaseidRRRRRRRoRRR(RTRwRRRRRt availableRRRRRt currentmoduleRRRRR7R((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRsT            c O`st}d}t|trTx[|D]+}t|s"t|t|q"q"Wn%t|syt|t|ndj|}d}|sd|kr|jd}nd|kr|jd}|dj|7}nt |||St|dt r|\}t|t s$t t j d} | jj} | j|y5tjj|j}tjj|| j| Wq|k rtjjSXn=|d} y| |d|Wn|k rtjjSXt|dS( s Assert that a code block/function call raises ``expected_exception`` and raise a failure exception otherwise. This helper produces a ``ExceptionInfo()`` object (see below). If using Python 2.5 or above, you may use this function as a context manager:: >>> with raises(ZeroDivisionError): ... 1/0 .. versionchanged:: 2.10 In the context manager form you may use the keyword argument ``message`` to specify a custom failure message:: >>> with raises(ZeroDivisionError, message="Expecting ZeroDivisionError"): ... pass Traceback (most recent call last): ... Failed: Expecting ZeroDivisionError .. 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 raises(ValueError) as exc_info: ... if value > 10: ... raise ValueError("value must be <= 10") ... assert exc_info.type == ValueError # this will not execute Instead, the following approach must be taken (note the difference in scope):: >>> with raises(ValueError) as exc_info: ... if value > 10: ... raise ValueError("value must be <= 10") ... >>> assert exc_info.type == ValueError Or you can use the keyword argument ``match`` to assert that the exception matches a text or regex:: >>> with raises(ValueError, match='must be 0 or None'): ... raise ValueError("value must be 0 or None") >>> with raises(ValueError, match=r'must be \d+$'): ... raise ValueError("value must be 42") Or you can 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) A third possibility is to use a string to be executed:: >>> raises(ZeroDivisionError, "f(0)") .. autoclass:: _pytest._code.ExceptionInfo :members: .. 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. See the official Python ``try`` statement documentation for more detailed information. sJexceptions must be old-style classes or derived from BaseException, not %ssDID NOT RAISE {0}Rtmatchs matching '{0}'iiN(RoRRWRRQRBR[R/tpopt RaisesContextRpRRt _getframetf_localsRjRhRRtSourcetcompileRRXtexec_t f_globalsRR( texpected_exceptionRCR_t__tracebackhide__RctexcRt match_exprRRRR((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytraisesHsD_           RcB`s#eZdZdZdZRS(cC`s(||_||_||_d|_dS(N(RRRR/R>(R1RRR((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRZs   cC`stjtjj|_|jS(N(R[R]RRRR>(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt __enter__scG`st}|ddkr&t|jntjdkrrt|dtsr|\}}}||||f}qrn|jj |t |jj |j }tjddkr|rtj n|jr|jj|jn|S(Niiii(ii(RoR/RRRt version_infoRt BaseExceptionR>RZt issubclassRBRt exc_clearRR(R1ttpRtexc_typeRRtsuppress_exception((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt__exit__s  (R\RRZRR(((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs  tapproxcB`s_eZdZdddZdZdZdZdZe dZ e j dZ RS(s[ Assert that two numbers (or two sets of numbers) are equal to each other within some tolerance. Due to the `intricacies of floating-point arithmetic`__, numbers that we would intuitively expect to be equal are not always so:: >>> 0.1 + 0.2 == 0.3 False __ https://docs.python.org/3/tutorial/floatingpoint.html 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 on sequences of numbers:: >>> (0.1 + 0.2, 0.2 + 0.4) == approx((0.3, 0.6)) True 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. Infinite numbers are another special case. They are only considered equal to themselves, regardless of the relative tolerance. 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 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. Only available in python>=3.5. `More information...`__ __ https://docs.python.org/3/library/math.html#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 ``numpy.allclose``. `More information...`__ __ http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.isclose.html - ``unittest.TestCase.assertAlmostEqual(a, b)``: True if ``a`` and ``b`` are within an absolute tolerance of ``1e-7``. No relative tolerance is considered and the absolute tolerance cannot be changed, 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...`__ __ https://docs.python.org/3/library/unittest.html#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. cC`s||_||_||_dS(N(texpectedtabstrel(R1RRR((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRZhs  cC`sdjd|jDS(Ns, cs`s|]}t|VqdS(N(trepr(t.0RU((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pys ns(RR(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt__repr__mscC`sjddlm}t||s+|g}nt|t|jkrJtStdt||jDS(Ni(tIterablecs`s!|]\}}||kVqdS(N((RtaRU((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pys vs(RRRR<RRtallRq(R1tactualR((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt__eq__ps  cC`s ||k S(N((R1R((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt__ne__zsc`seddlm}fd}tj|rQgjD]}||^q;S|jgSdS(Ni(Rc`st|jjS(N(tApproxNonIterableRR(RU(R1(s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs(RRRt _expected(R1Rtapprox_non_iterRU((R1s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyR}s  cC`s ||_dS(N(R(R1R((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRsN( R\RRR/RZRRt__hash__RR6Rtsetter(((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRsp    RcB`sMeZdZdddZdZdZdZdZe dZ RS(s5 Perform approximate comparisons for single numbers only. In other words, the ``expected`` attribute for objects of this class must be some sort of number. This is in contrast to the ``approx`` class, where the ``expected`` attribute can either be a number of a sequence of numbers. This class is responsible for making comparisons, while ``approx`` is responsible for abstracting the difference between numbers and sequences of numbers. Although this class can stand on its own, it's only meant to be used within ``approx``. cC`s||_||_||_dS(N(RRR(R1RRR((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRZs  cC`st|jtrt|jStj|jr>t|jSydj|j}Wntk rmd}nXt j ddkrdj|j|Sdj|j|SdS(Ns{:.1e}s???iis {0} +- {1}u {0} ± {1}( RRtcomplexRptmathtisinfR[t toleranceRRRR(R1tvetted_tolerance((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs    cC`sI||jkrtStjt|jr/tSt|j||jkS(N(RRoR R RRR(R1R((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs cC`s ||k S(N((R1R((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRscC`sd}||jd}|dkr?tdj|ntj|r]tdn|jdkr|jdk r|Sn||jdt|j}|dkrtdj|ntj|rtdnt||S( NcS`s|dk r|S|S(N(R/(RUR>((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRsg-q=is(absolute tolerance can't be negative: {}s absolute tolerance can't be NaN.gư>s(relative tolerance can't be negative: {}s relative tolerance can't be NaN.( RRRR[R tisnanRR/Rtmax(R1t set_defaulttabsolute_tolerancetrelative_tolerance((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs   N( R\RRR/RZRRR RR6R(((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs    Rc B`seZdZd Zd d d ed d d d dZdZedZ dZ edZ dZ dZ dZRS( s] a Function Item is responsible for setting up and executing a Python test function. c C`stt|j||d|d|||_|tk rF||_n|jj|jj|r||_ |jj|jn|r|jj|n| dkr|j j j |j|j|jd|j } n| |_| j|_|j| |_dS(NRTRwRl(RRRZRkRR0RRhRRR/RwRRRuRRjRmR{R|t _initrequestR( R1R3RuRCRTRRRRwRR((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRZs&         cC`si|_|jr4t|d stdnUt|dr|j}|j s\t|j|_t|dr|j|_qntj ||_ dS(NRs3yielded functions (deprecated) cannot have funcargsRy( RlRjRYRRRt_genidRyRtFixtureRequestt_request(R1R((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs     cC`st|jd|jS(s#underlying python 'function' objectR((R-R0(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRZ#scC`sD|j}|jd}|dkr1|| }nt|jj|S(NRi(R3tfindR-RuR0(R1R3RT((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyR(s    cC`s|S(s@(compatonly) for code expecting pytest-2.2 style request objects((R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyt _pyfuncitem/scC`st|dddk S(NRk(R-R/(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRj4scC`s|jjd|dS(s' execute the underlying test function. RpN(R~Rt(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytruntest7scC`s$tt|jtj|dS(N(RRRRt fillfixtures(R1((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyR;sN(R\RRR/RRRZRR6RZRRRjRR(((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pyRs     (aRt __future__RRRRzRRRRR t itertoolsRRRRRRRt_pytest._pluggyt_pluggytpluggyRRt_pytest.compatRR R R R R RRRRRRRRt_pytest.runnerRR R!RtrstripR"tdirpathR$R%R*R8RRRURfRhRoRtRR|RR/RR[RRt CollectorRRRtFileRRRRRR,RR%R&R_tFuncargnamesCompatAttrRRRRRR@RR=RRRCRRRtItemR(((s./tmp/pip-build-hU8Cw8/pytest/_pytest/python.pytsz        ^      9m D   ?'  B  !   7  5 !d