gtdZddlZddlZddlZddlZddlZddlmZddlZddl Z ddl m Z ddl Z ddl mZddl mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZej e j!"Z#ej ej!$dZ%dZ&d Z'd Z(d Z)d Z*d Z+e j,ddZ-e j,ddZ.dZ/dZ0e j,ddZ1dZ2Gdde3Z4Gdde4Z5Gdde5e j6Z7dZ8dZ9Gdd e j:e7Z;dBd!ZGd%d&e7Z?Gd'd(e5Z@Gd)d*e@e7ZAd+ZBd,ZCGd-d.e3ZDGd/d0ejEZFd1ZGdBd2ZHdBd3ZIdCd4ZJd5ZKd6ZLd7ZMd8ZNd9ZOGd:d;e3ZPGd<d=e3ZQGd>d?e3ZRGd@dAe@e jSejEZTdS)Dz9 Python test discovery, setup and run of test functions. Ncount) MarkerError)fixtures) isclass isfunction is_generator_escape_strings REGEX_TYPE STRING_TYPESNoneTypeNOTSET get_real_func getfslineno safe_getattr getlocationenumocc|jjjj}d|vod|v}|rdStj|j}|tko|t S)N<>F) framecoderaw co_filenamepypathlocalcutdir1reltocutdir2)entry raw_filename is_generatedps D/granary/edev/quantum/lib/python3.11/site-packages/_pytest/python.pyfilter_tracebackr'sj;#'3L,&>3,+>Lu  ej!!A < 0 0 000cbfd}dd}t|dd|S)Ncj|tt}||jSdSN) getparentgetattrpytestobj)selfnodenames r&getzpyobj_property..get-s3~~gfd3344  8O  r(zpython z3 object this node was collected from (can be None).)lowerproperty)r2r3docs` r&pyobj_propertyr7,sM **,,,, C CtS ) ))r(c|d}|dddddd|d dd dd |d d gd|dd ddgd|dd dgd|dd dgd|ddddgdddS) Ngeneralz --fixturesz --funcargs store_true showfixturesFz4show available fixtures, sorted by plugin appearance)actiondestdefaulthelpz--fixtures-per-testshow_fixtures_per_testzshow fixtures per test usefixturesargsz5list of default fixtures to be used with this project)typer>r? python_filesz test_*.pyz *_test.pyz9glob-style file patterns for Python test module discoverypython_classesTestz6prefixes or glob names for Python test class discoverypython_functionstestzDprefixes or glob names for Python test function and method discovery --import-modeprependappend importmodezNprepend/append to sys.path when importing test modules, default is to prepend.)r>choicesr=r?)getgroup addoptionaddini)parsergroups r&pytest_addoptionrS6sP OOI & &E OOL,"JLLL OO % %  MM-fb DFFF MM.vk* HJJJ MM"& EGGG MM$6F9 !!! OOOYH%L&'''''r(cz|jjrt|dS|jjrt|dSdSNr)optionr;r@configs r&pytest_cmdline_mainrYSsL }!Vq }+v&&&qr(cgd}|D]F}t|j|r/d}t||jj|G |jj}n#t $rYdSwxYw|D]}|j|ji|jdS)N) parameterize parametrise parameterisez/{0} has '{1}', spelling should be 'parametrize') hasattrfunctionrformat__name__ parametrizeAttributeErrorrBkwargs)metafunc alt_spellingsattrmsgmarkersmarkers r&pytest_generate_testsrk\sDCCMLL 8$d + + LCCcjj):)CTJJKK K L#/ <<fk;V];;;;<L$$&&! j&'''&*3 * *C$SMHSMM   x   4r(c"|j}|dkr|j|s6|jdD]}||rndS|j|}|||SdS)N.pyrDrparent)extsession isinitpathrXgetinifnmatch gethookproxypytest_pycollect_makemodule)rrrpatihooks r&pytest_collect_filers (C e||~((.. }++N;;  <<$$Ev++D1100d60JJJ|r(c"t||Sr+)rqrs r&rrs $  r() hookwrapperc#KdV}|}|tt|rO|||r7|d}||||dSdS|||rt|d|}t|s8tt|s| dd|zdSt|ddr]t|rt||}n#t|||}||dSdSdS) Nrr)r__func__C2z/cannot collect %r because it is not a function.)rmessage__test__T) get_result StopIterationr istestclass_getcustomclass force_resultistestfunctionr-rrwarnr rulist _genfunctions) collectorr2r/outcomeresrrs r&pytest_pycollect_makeitemrseeG     C s||&  d + + @--g66E  tI!>!>!> ? ? ? ? ? @ @  ! !#t , ,&c:s++3 &:mC.@.@#A#A & NNA      S*d + + &C   ?Y7779224==>>   % % % % %&& & &r(cdSr+r{rXvals r&pytest_make_parametrize_idrs 4r(cPeZdZedZedZedZdS) PyobjContextrqrrrsN)ra __module__ __qualname__r7moduleclsinstancer{r(r&rrs; ^H % %F . ! !C~j))HHHr(rcBeZdZdZeZdZd dZdZdZdS) PyobjMixinc2d}d}t||ddS)Ncbt|dd}||x|_}|SN_obj)r-_getobjrr0r/s r&fgetzPyobjMixin.obj..fgets1$--C{"&,,..0 CJr(c||_dSr+)r)r0values r&fsetzPyobjMixin.obj..fsets DIIIr(zunderlying python object)r5)rrs r&r/zPyobjMixin.objs5       dD*DEEEr(c@t|jj|jSr+)r-rr/r2r0s r&rzPyobjMixin._getobjst{ 222r(TFc|}|g}|D]}t|tr|j}t|t r<|dsJ|dd}|r|r||n|||d|}| ddS)z7 return python path relative to the containing module. rN.z.[[) listchainreverse isinstancersr2rqendswithrKjoinreplace)r0 stopatmodule includemodulechainpartsr1r2ss r& getmodpathzPyobjMixin.getmodpaths     D$)) 9D$'' }}U+++++CRCy$+ T***E LL      HHUOOyys###r(c*t|jSr+)rr/rs r& _getfslinenozPyobjMixin._getfslinenos48$$$r(c\|j}t|dd}t|tr>tj|jj}|dr |dd}|}nt|\}}| }t|tsJ|||fS)Ncompat_co_firstlinenoz.pyc) r/r-rintsysmodulesr__file__rrr)r0r/rfspathlinenomodpaths r& reportinfozPyobjMixin.reportinfosh '-Dd K K +S 1 1 .[09Fv&& %*FF(--NFF//##&#&&&&&vw&&r(N)TF)rarrr/rrrrr{r(r&rrstFFF #%%C333$$$$*%%%'''''r(rcDeZdZdZdZdZdZdZdZdZ dZ d Z d S) PyCollectorc.|d|S)NrG_matches_prefix_or_glob_optionr0r2s r&funcnamefilterzPyCollector.funcnamefilters223EtLLLr(c(t|ddduS)zg Look for the __test__ attribute, which is applied by the @nose.tools.istest decorator rFT)rrs r& isnosetestzPyCollector.isnosetest sCU33t;;r(c.|d|S)NrErrs r&classnamefilterzPyCollector.classnamefilters223CTJJJr(c||s||o&t|ddotj|duS)N__call__F)rrrrgetfixturemarkerr0r/r2s r&rzPyCollector.istestfunctionsX   & & >$//#*>*> \ j% 0 0 \5=5Ns5S5SW[5[ r(cV||p||Sr+)rrrs r&rzPyCollector.istestclasss'##D))AT__S-A-AAr(c|j|D]>}||rdSd|vsd|vsd|vrtj||rdS?dS)zs checks if the given name matches the prefix or glob-pattern defined in ini configuration. T*?rF)rXr startswithr)r0 option_namer2rVs r&rz*PyCollector._matches_prefix_or_glob_options{ k((55  Fv&& tt--3&==C6MMOD&115Bttur(ct|jddsgSt|jdig}tj|jjD]}||ji}g}|D]y}t|D]U\}}||vr d||<| ||}|(t|ts|g}| |Vz| d|S)NrT__dict__c:|ddS)N)r)items r&z%PyCollector.collect..Ds 1 1"1" 5r()key) r-r/inspectgetmro __class__rKrritemsmakeitemrextendsort) r0dictsbaseclsseenldicr2r/rs r&rxzPyCollector.collect.s%txT22 I:r223~dh&899 + +G LL) * * * *   C!#))++..   c4<<!T mmD#..;!#t,, %C   55666r(c<|j|||S)N)rr2r/)rr)r0r2r/s r&rzPyCollector.makeitemGs(z333400 0r(c #lK|tj}|t}|r|jpd}t ||||jj}||||}t|||j ||}g} t|dr| |j t|dr"| |j | r/|j j | t|n|j ||d} |js| |||VdSt%j||||jD]*} |d| jd} | | || ||| jdi| V+dS) N)rrrk)rert)r fixtureinfor]T)r2rcallspeccallobjr keywords originalname)r,rqr/rrtransfer_markersr_fixturemanagergetfixtureinfoMetafuncrXr^rKrkr call_extradictr_callsradd_funcarg_pseudo_fixture_defid) r0r2funcobjrclscolrfmr remethodsrtr subnames r&rzPyCollector._genfunctionsLs ''+&&#+t#v... \ )''gs;; G[$+ #F444 62 3 3 9 NN67 8 8 8 3/ 0 0 8 NN33556 7 7 7  @ J , 7 78NOO  "7BSTTO  &   o . . . . . ' &r() rarr__doc__rrxr*rP __classcell__rs@r&rqrqso55BBB-----%%%N / / / / / / /r(rqcn|t||/jj}tjr|dz}|rfdSSdS)a^ 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. Nr4cSr+r{) param_objresultsr&rz+_get_xunit_setup_teardown..s66),,r()_get_xunit_func__code__ co_argcountrismethod)r& attr_namerV arg_countrWs ` @r&rNrNsv'2 I VY / /F O/  F # #  NI  ,,,,, ,Mr(cTt||d}tj||SdS)zReturn 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-rr)r/r2meths r&rXrXs3 3d # #D &&. /.r(ceZdZdZdZdZdS)rrz Collector for test methods. c(t|jr%|dd|jjzgSt |jr%|dd|jjzgS|dd|gS)NC1zBcannot collect test class %r because it has a __init__ constructorzAcannot collect test class %r because it has a __new__ constructorrsz())r2r)hasinitr/rrahasnewrrs r&rxz Class.collects 48    IId')-):; < < <I DH    IId248H4EF G G GI0$$Z00d4HHHIIr(cFtjd}|2t|d|}t|d|}|jtjdd=tdtdfddSdS)N setup_classim_funcrteardown_classc$jSr+)r/) fin_classr0sr&rzClass.setup..sii&9&9r()rXr/r-rO)r0rfrjs` @r&rPz Class.setups%dh >>  "!+y+FFK!+z;GGK K ! ! !DH&6==   9i@@I :yAAI   99999 : : : : : ! r(N)rarrrQrxrPr{r(r&rrrrs;'' J J J ; ; ; ; ;r(rrc*eZdZdZfdZdZxZS)rsc4|jSr+)rr/rs r&rzInstance._getobjs{   r(c|jj|tt|Sr+)rrr,r-rsrxr.s r&rxzInstance.collects8 $33D999Xt$$,,...r(cB||_|jSr+)rr/rs r& newinstancezInstance.newinstance s<<>>xr()rarrrrxrorRrSs@r&rsrssV!!!/////r(rsc8eZdZdZdZdZdfd Zd dZxZS) FunctionMixinz: mixin for the code common to Function and Generator. ct|dr|j}nYt|jtr3|j}||_n |jj}tj |jrd}d}nd}d}t|||j}| |t|||j}|| |dSdS)z' perform setup for this test function. _preservedparent setup_methodteardown_methodsetup_functionteardown_function)rVN) r^rsrrrsrorr/rr[rNrO)r0r/ setup_name teardown_namesetup_func_or_methodteardown_func_or_methods r&rPzFunctionMixin.setups 4+ , , "'CC  X . . "+))++C||~~DHH+/C  DH % % 0'J-MM)J/M8jTXT\]]]  + " " "";CZ^Zb"c"c"c " .   5 6 6 6 6 6 / .r(cpt|dr|jjjs tjt|j}|j |j }}|j }| ||}||kr:| |}||kr| t}|s|}| |_ |jjjdkrCt!|j dkr-|j ddD]}|ddSdSdSdSdS) Nr)r firstlineno)rautorr4rr1)r^rXrV fulltracer9r:Coderr/rr} tracebackcutfilterr'tbstylelenset_repr_style)r0excinforrr}r ntracebackr"s r&_prunetracebackzFunctionMixin._prunetraceback)sT 4  6);)E 6=%%mDH&=&=>>D $ 4+;+D)I"DkJJJY&&'^^^66 **!+!2!23C!D!DJ%/%. * 1 1 3 3G {!)V33w())A--!(!21R4!866,,W5555' 6 6 6 6 43--66r(longc|tjjr0|jjs$t j|jStt| ||S)Nr2) errisinstancer.ryrzrpytracer_builtin_totextr-rq_repr_failure_py)r0rr3rs r&rzFunctionMixin._repr_failure_py?so  !6 7 7 :=( :{**7=999]D))::7; r(Ncz| Jd|jjj}|dkrd}|||S)NzXXX outerr usage is deprecatedr~rr2)rXrVrr)r0routerrr3s r& repr_failurezFunctionMixin.repr_failureFsF~~?~~~ "* F??E$$WE$:::r()rr+) rarrrQrPrrrrRrSs@r&rqrqsy777,666,;;;;;;;;r(rqceZdZdZdZdS)ruc Dddlm}|jj||jj|_g}i}t|D]\}}| |\}}}t|st|jd||d|z}nd|z}||vrt|d|d||<| ||||||jd |j|j |S) Nr) deprecatedz yielded non callable test z[%d]z['%s']z& generated tests with non-unique name T)rBr rb) fslocation)r9rr _setupstatepreparerr/rs enumerate getcallargscallable TypeError ValueErrorrKrtrXr YIELD_TESTSr) r0rrrixr2callrBs r&rxzGenerator.collectOsG '&&&&&  ((... $  dhhjj)) S SDAq#//22 D$D>> VDHHHdd TUUU|z$t|| PTPTPTVZVZ![\\\DJ HHT]]4D$]GG H H H K  T:#9dk  R R R Rr(ct|ttfs|f}t|dtjjr|d}|dd}nd}|d|dd}}|||fS)Nrr4)rtuplerrbuiltin _basestring)r0r/r2rrBs r&rzGenerator.getcallargshsy#t}-- &C c!fbj4 5 5 q6Dabb'CCDVSWdT4r(N)rarrrxrr{r(r&ruruNs22      r(rucLt|dd}|r|tjkSdS)N__init__)r-objectr)r/inits r&rcrcus2 3 D ) )D 'v&&''r(cLt|dd}|r|tjkSdS)N__new__)r-rr)r/news r&rdrd{s2 #y$ ' 'C %fn$$%%r(cHeZdZdZdZdZdZedZdZ dZ dS) CallSpec2c||_i|_g|_i|_t|_t |_t|_i|_ i|_ i|_ dSr+) rer_idlistparamsr _globalidset_globalid_args _globalparam _arg2scopenumrindices)r0res r&rzCallSpec2.__init__sS     !ee"  r(ct|j}|j|j|j|j|j|j|j|j|j|jt|j |_ |j |_ |j |_ |j |_ |Sr+) rrerupdaterrrrrrrrr)r0recss r&copyzCallSpec2.copys t} % % 4=))) %%% 4=))) $,'''  2333$,'' ~  /+ r(cN||jvs ||jvrtd|dS)Nz duplicate )rrr)r0rs r&_checkargnotcontainedzCallSpec2._checkargnotcontaineds8 $+   !5!5*cc344 4"6!5r(c |j|S#t$r'|jturt ||jcYSwxYwr+)rKeyErrorrrrrs r&getparamzCallSpec2.getparamsZ %;t$ $ % % % F** &&&$ $ $ $ %s .AAc xdtttd|jS)N-)rmapstrrrrs r&rz CallSpec2.ids*xxCdl!;!;<<===r(c"t||D]I\}} ||||} | t|| |<||j|<||j|<J|j||j|dSr+) ziprr-rrrrKrr) r0valtypesrvalsetrrscopenum param_indexrrvaltype_for_args r&setmultizCallSpec2.setmultis8V,, / /GC  & &s + + +&smO25GD/ * *3 / +DL &.D s # # B X&&&&&r(c&|D]}|||j||tur|j||tur|jtusJ||_|D]}tj|j |<dSr+) rrrrrrKrrscopenum_functionr)r0rrparamrrs r&setallzCallSpec2.setalls * *A  & &q ) ) ) ) X&&& V   L   # # #   $.... %D  A AC&.&@D s # # A Ar(N) rarrrrrrr5rrrr{r(r&rrs      555%%%>>X> ' ' ' A A A A Ar(rc4eZdZdZddZ ddZdeefdZdS) ra Metafunc objects are passed to the ``pytest_generate_tests`` hook. They help to inspect a test function and to generate tests according to test configuration or values specified in the class or module where a test function is defined. Nc||_||_||_|j|_||_g|_tj |_ |j |_ dSr+) rXrr_ names_closure fixturenamesrrrrr_idsname2fixturedefs_arg2fixturedefs)r0r_r rXrrs r&rzMetafunc.__init__s\  ! (5 JNN$$ + <r(Fc ddlm}ddlm}ddlm}g} g} |D]:} || \} } | | | | ;| }t|ttfs>d| dD}t|dkr d|D}|sktft|zg}t|j\}}tjd ||jj||fz }|j|ig} |t)||j|}||d |j }i}|D]R}||jvrGt|ttfr ||vrdnd}n|rdnd}t3|jd|d|S|durt4|d}n|durt4|d}n`t|ttfrDt4|d}|D]&}||vrt3d|jd|dd||<'d }t9|r|}d }|rt|t|kr.t3dt|t|fz|D]T}|Pt|t:jjs1d}t3|||tA|jfzUtC|||||j"}g}|j#ptI|gD]}tK||| tM}|D]n\}}}}t|t|ksJ|'|}|(|||||||||o||_#d S)a Add new invocations to the underlying test function using the list of argvalues for the given argnames. Parametrization is performed during the collection phase. If you need to setup expensive resources see about setting indirect to do it rather at test setup time. :arg argnames: a comma-separated string denoting one or more argument names, or a list/tuple of argument strings. :arg argvalues: The list of argvalues determines how often a test is invoked with different argument values. If only one argname was specified argvalues is a list of values. If N argnames were specified, argvalues must be a list of N-tuples, where each tuple-element specifies a value for its respective argname. :arg indirect: The list of argnames or boolean. A list of arguments' names (subset of argnames). If True the list contains all names from the argnames. Each argvalue corresponding to an argname in this list will be passed as request.param to its respective argname fixture function so that it can perform more expensive setups during the setup phase of a test rather than at collection time. :arg ids: list of string ids, or a callable. If strings, each is corresponding to the argvalues so that they are part of the test id. If None is given as id of specific test, the automatically generated id for that argument will be used. If callable, it should take one argument (a single argvalue) and return a string or return None. If None, the automatically generated id for that argument will be used. If no ids are provided they will be generated automatically from the argvalues. :arg scope: if specified it denotes the scope of the parameters. The scope is used for grouping tests by parameter instances. It will also override any fixture-function defined scope, allowing to set a dynamic scope using test context or configuration. r) scope2index)extract_argvalue)safereprc^g|]*}||+Sr{)strip.0rs r& z(Metafunc.parametrize..s-LLLa!''))L LLLr(,r4cg|]}|fSr{r{)rrs r&rz(Metafunc.parametrize..s999cV999r(z0got empty parameter set %r, function %s at %s:%d)reasonNz call to {0})descrfixtureargumentz uses no  TrFrzindirect given to z : fixture z doesn't existz%d tests specified with %d idsz1ids must be list of strings, found: %s (type: %s)))_pytest.fixturesr _pytest.markrpy.iorrKrrrsplitrrrr_r.r skipramarkname_find_parametrized_scoperr`rbrrrfromkeysrrrrrCidmakerrXrrrrrr) r0r argvaluesindirectidsscoperrrunwrapped_argvalues newkeywordsmaybe_marked_argsargvalnewmarksfsrnewmarkrrrr2idfnid_valuerhnewcallsr elementsa_idrrr newcallspecs r&rbzMetafunc.parametrizesN 100000111111""""""  !* ) ) //0ABB FH  & &v . . .   x ( ( ( (' (UDM22 :LL8>>#+>+>LLLH8}}!!99y999  8 S]]23I%T]33JBk&&Idm4b&MBB'CCG$,g67K =,Xt7LhWWE; --d.>??AAA 7 7C$+++h 66A(+x99ZDD(0@99jD  MMM4446777 , t  }}Xx88HH   }}Xz::HH 5$- 0 0 )}}Xz::H ) )h&&$*%)]]]CCC&9::: (  C== DC  Z3xx3y>>)) !A!$YSD;";<<< Z Z' 8RZE[0\0\'MC$SHHX,>,>X@W+X%XYYYh 4dkBB 8 $'8 - -H3 ;@@H7? - -3fh 6{{c(mm3333&mmD11 $$Xx%-xFFF ,,,,  -  r(c|t|tsJ|&|D]"}||jvrtjd|z#ni}|t d|t urt|j}t|}||j vrt d|z|j |t|}| ||||j|dS)a (deprecated, use parametrize) Add a new call to the underlying test function during the collection phase of a test run. Note that request.addcall() is called during the test collection phase prior and independently to actual test execution. You should only use addcall() if you need to specify multiple arguments of a test function. :arg funcargs: argument keyword dictionary used when invoking the test function. :arg id: used for reporting and identification purposes. If you don't supply an `id` an automatic unique id will be generated. :arg param: a parameter which will be exposed to a later fixture function invocation through the ``request.param`` attribute. Nz%funcarg %r not used in this function.zid=None not allowedzduplicate id %r)rrrr.ryrrrrrraddrrrK)r0rrrr2rs r&addcallzMetafunc.addcallRs :h#=#=    P Pt000K G$ NOOO PH :233 3 <<T[!!B WW ??.344 4 b t__ (B&&& 2r(NN)FNN)rarrrQrrbrrr{r(r&rrsr ====(DHrrrrh $f""""""r(rcddlm}t|ttf}|dup|ot ||k}|r>|pi}d|D}|rt|D] }||vr|cS dS)a}Find the most appropriate scope for a parametrized call based on its arguments. When there's at least one direct argument, always use "function" scope. When a test function is parametrized and all its arguments are indirect (e.g. fixtures), return the most narrow scope based on the fixtures used. Related to issue #1832, based on code posted by @Kingdread. r)scopesTc.g|]\}}|djS)r)r)rr2 fixturedefs r&rz,_find_parametrized_scope..s$WWW/?tZz!}*WWWr(r_)rrrrrrrreversed) rarg2fixturedefsrrindirect_as_listall_arguments_are_fixtures fixturedefs used_scopesrs r&rrws('''''!(T5M::!)T!1"P!1!Oc(mmx6O!!%+ WW;CTCTCVCVWWW  !!&)) ! !K'' LLL( :r(c|r. ||}|rt|Sn#t$rYnwxYw|r |j||}|r|St |t rt|St |t tttfrt|St |trt|j St)t |tjrt|St|rt!|dr|jSt|t|zS)Nrra)r rzhookrrr floatrboolr rr patternrEnumrr^ra)rargnameidxrrXrhook_ids r&_idvalrsP  S A *&q))) *    D +88C8PP  N#|$$ s### C%dH5 6 63xx C $ $s{+++ jdi88 3xx '#z22| w<<C  s ! ..c|t|ks|3fdt||D}d|St|S)Nc <g|]\}}t||Sr{)r)rrrrXrrs r&rz_idvalset..s=>>>#sG#wT6::>>>r(r)rrrr )rrrrrrXthis_ids` ` ` r& _idvalsetrs {sc#hh#c(*:>>>>>>'*68'<'<>>>xx   s3x(((r(crfdt|DtttkrgfdD}tjd}tD]4\}}||vr+|t ||z|<||xxdz cc<5S)Nc >g|]\}}t||Sr{)r)rvalindexrrrXrrs r&rzidmaker..s? 9 9 9x XvxsF C C 9 9 9r(cFg|]}|dk|S)r4r)rtestidrs r&rzidmaker..s/HHH#))F2C2Ca2G2Gf2G2G2Gr(cdSrUr{r{r(r&rzidmaker..s1r(r4)rrr collections defaultdictr) rrrrrX duplicatescountersindexr#s ` ``` r&rrs 9 9 9 9 9 9 9#,Y#7#7 9 9 9C 3s88}}C  HHHH3HHH *9955&s^^ & &ME6###c(6*:&;&;;E    A%   Jr(c0ddlm}||tSNr) wrap_session) _pytest.mainr,_show_fixtures_per_testrXr,s r&r@r@s')))))) < 7 8 88r(c* ddl}|tj|j||dfdfd  fd}|jD] }||dS)NrverbosecNt|}|Sr+)r bestrelpath)rloccurdirs r& get_best_relz-_show_fixtures_per_test..get_best_rels&$''!!#&&&r(c|j} dkr|drdS dkr'|j}d||}n|}|dd}|jj}|rf|dD]<}||=dS|dd dS) NrrHz {0} -- {1}Tgreenz {0} zno docstring availablered)rrrr`linerQrr) fixture_defrbestrel funcargspecINDENT fixture_docr=r6twr1s r& write_fixturez._show_fixtures_per_test..write_fixtures% a<.write_items,=  F,t}--   s*11$)<<=== sGNN7++,,,%+,<,B,B,D,D%E%E , , !G\+++  M,r* + + + +  , ,r() _pytest.configperform_collectrrrrXcreate_terminal_writergetvaluer) rXrr9rIrr5r6rCr1rDs @@@@@r&r.r.s  W]]__F  . .v 6 6Booi((G'''''GGGGGGG*,,,,,,,&  4r(c0ddlm}||tSr+)r-r,_showfixtures_mainr/s r&r;r;s')))))) < 2 3 33r(c ddl}|tj}|j|}|d}|j}g}t}|j D]\} } | J| s | D]} t| j |} | j| f|vr#|| j| f|t#| j| j j|| | j| f|d} |D]#\}}}} } | |krD|ds/||dd||} |dkr | ddkrf|dkr| d|}n| }||d t| j |} | j jpd }|rV|d D],}|d |z-|d | d d%dS)Nrr1z_pytest.rzfixtures defined from rHz -- Tr8r:z z: no docstring availabler;)rJrKrrrrXrLrMrrrrrrrrrKrbaseidrr3rrr=rFrQrr)rXrr9r5rCr1r availablerrrr r4 currentmodulerRrr?r@r6r=s r&rOrOs  W]]__F  . .v 6 6Booi((G  BI 55D " 3 9 9 ; ; ? ?&&&  % ? ?Jjov66C"C(D00 HHj(#. / / /   c*"344(o8$0055(0*> ? ? ? ?  ?NNM8A4* F " "$$Z00 ' ssABBB & a<>> 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 ... 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:: >>> with raises(OSError) as exc_info: assert 1 == 1 # this will execute as expected raise OSError(errno.EEXISTS, 'directory exists') assert exc_info.value.errno == errno.EEXISTS # this will not execute Instead, the following approach must be taken (note the difference in scope):: >>> with raises(OSError) as exc_info: assert 1 == 1 # this will execute as expected raise OSError(errno.EEXISTS, 'directory exists') assert exc_info.value.errno == errno.EEXISTS # this will now execute 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. Tr)BuiltinAssertionErrorzJexceptions must be old-style classes or derived from BaseException, not %szDID NOT RAISE {0}rr4N)AssertionError_pytest.assertion.utilrVrrrrrCr`pop RaisesContextrr _getframef_localsrrr9r:Sourcecompilerrexec_ f_globalsr;r.ry) expected_exceptionrBrd__tracebackhide__rhrGrrrr4rs r&rvrv6scd^++ " " " " " " 1C$e,,8% 1 1C3<< 1d3ii000 1 1' ( (8d#5666777!(();<>> 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. Nc0||_||_||_dSr+expectedabsrelr0rrrtrss r&rzapprox.__init__@  r(cJdd|jDS)Nz, c34K|]}t|VdSr+)reprrs r& z"approx.__repr__..Fs(88Qa888888r()rrrrs r&__repr__zapprox.__repr__Es%yy88$-888888r(cddlm}t||s|g}t|t|jkrdSt dt ||jDS)NrIterableFc3(K|] \}}||kVdSr+r{)rars r&rzz approx.__eq__..Ns*AAda16AAAAAAr()r%r~rrrrallr)r0actualr~s r&__eq__z approx.__eq__Hsv((((((&(++ XF v;;#dm,, , ,5AAc&$-&@&@AAAAAAr(c||k Sr+r{r0rs r&__ne__z approx.__ne__RdN##r(cddlm}fdtj|rfdjDSjgS)Nrr}c:t|jjSr+)ApproxNonIterablertrs)rr0s r&rz!approx.expected..[s$5a48$L$Lr(c&g|] }|Sr{r{)rrapprox_non_iters r&rz#approx.expected..]s#???1OOA&&???r()r%r~r _expected)r0r~rs` @r&rrzapprox.expectedUsk )(((((LLLL dnh / / 5??????? ?#ODN334 4r(c||_dSr+)r)r0rrs r&rrzapprox.expectedas !r(r) rarrrQrr{r__hash__rr5rrsetterr{r(r&rwrwsoob 999BBBH$$$ 5 5X 5_""_"""r(rwcFeZdZdZddZdZdZdZdZe dZ dS) ra5 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``. Nc0||_||_||_dSr+rqrus r&rzApproxNonIterable.__init__srvr(cHtj|jrt|jS d|j}n#t $rd}YnwxYwd|j|}tjddkr| dS|S)Nz{:.1e}z???u {0} ± {1}rrzutf-8) mathisinfrrrr` tolerancerrriencode)r0vetted_tolerance plus_minuss r&r{zApproxNonIterable.__repr__xs :dm $ $ &t}%% % %'t~>>   % % %$    %'--dm=MNN  A ! # #$$W-- - sA AAc||jkrdStjt|jrdSt|j|z |jkS)NTF)rrrrrsrrs r&rzApproxNonIterable.__eq__sU T] " "4 :c$-(( ) ) 54=6)**dn<s r&rz-ApproxNonIterable.tolerance..samr(g-q=rz(absolute tolerance can't be negative: {}z absolute tolerance can't be NaN.gư>z(relative tolerance can't be negative: {}z relative tolerance can't be NaN.)rsrr`risnanrtrrmax)r0 set_defaultabsolute_tolerancerelative_tolerances r&rzApproxNonIterable.tolerances HH )[599  ! !GNNOabbcc c :( ) ) A?@@ @ 8 x#)))[4883t};M;MM  ! !GNNOabbcc c :( ) ) A?@@ @%'9:::r(r) rarrrQrr{rrrr5rr{r(r&rrfs   0==="H$$$;;X;;;r(rceZdZdZdZdddeddddffd ZdZedZ dZ edZ dZ d Z fd ZxZS) rtz] a Function Item is responsible for setting up and executing a Python test function. Nc Htt|||||||_|tur||_|j|jj|r&||_ |j|j|r|j|| E|j j |j |j|j| } | |_| j|_|| |_dS)N)rXr)r)r-rtrrrr/rrrr rrrrrr~rrr _initrequestr) r0r2rrBrXr r rrr rrs r&rzFunction.__init__s+ h&&tVF/6 ' 8 8 8 & DH TX.///  4$DM M !2 3 3 3  + M  * * *  ,6EE TXtx!44666F88K('5  )r(c4i|_|rt|dr JdnHt|dr8|j}|jrJ|j|_t|dr |j|_tj||_ dS)Nr z3yielded functions (deprecated) cannot have funcargsr) rr~r^r r_genidrrFixtureRequest_request)r0r s r&rzFunction._initrequests  " " $ $ 0tZ00 G GE G G G GtZ(( 0=#,,,,&k 8W--0!)DJ /55 r(c8t|jd|jS)z#underlying python 'function' objectrg)r-r/rs r&r_zFunction.functionstxDH555r(c|j}|d}|dkr |d|}t|jj|S)Nrr)r2findr-rr/)r0r2rs r&rzFunction._getobjsBy IIcNN 778Dt{---r(c|S)z@(compatonly) for code expecting pytest-2.2 style request objectsr{rs r& _pyfuncitemzFunction._pyfuncitem s  r(c(t|ddduS)Nr)r-rs r&r~zFunction._isyieldedfunctionstWd++477r(c<|j|dS)z' execute the underlying test function. )rN)rrrs r&runtestzFunction.runtests! %%%66666r(c~tt|tj|dSr+)r-rtrPr fillfixturesr.s r&rPzFunction.setups6 h##%%%d#####r()rarrrQrrrrr5r_rrr~rrPrRrSs@r&rtrtsF*.tt!))))))< 6 6 666X6...X888777$$$$$$$$$r(rtr+)NNN)UrQrrrr%r itertoolsrrr.rrr9_pytest._pluggy_pluggypluggyr_pytest.compatrrr r r r r rrrrrrrrrdirpathr!rstriprr'r7rSrYrkrnhookimplr|rrrrrrrr Collectorrr"rFilerqrNrXrrrsrqrurcrdrFuncargnamesCompatAttrrrrrrr@r.r;rOrvrZrwrItemrtr{r(r&rs6??   $$$$$$  '--( ) ) 1 1 3 3 '--..t44 5 5 1 1 1***''': < < <        K K K   T"""&&#"&6 *****6*** 5'5'5'5'5'5'5'5'nj!j!j!j!j!*f.j!j!j!Z K K K$$$ ;/;/;/;/;/V[+;/;/;/|(;;;;;K;;;4     {   <;<;<;<;<;J<;<;<;~$ $ $ $ $ {$ $ $ N''' %%% ?A?A?A?A?A?A?A?ADqqqqqx.qqqh4!!!!4))))    999 444n444000j||||FFFFFFFFF4U"U"U"U"U"VU"U"U"p`;`;`;`;`;`;`;`;NK$K$K$K$K$}fk8+JK$K$K$K$K$r(