B ܇\@sdZddlmZddlmZddlmZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl mZddlZddlZddlZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddlm$Z$ddlm%Z%ddlm&Z&ddlm'Z'ddlm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.dd l/m0Z0dd!l/m1Z1dd"l2m3Z3dd#l4m5Z5dd$l6m7Z7d%d&Z8d'd(Z9d)d*Z:d+d,Z;d-d.Zd5d6Z?d7d8Z@e*d/d9d:d;ZAdsdd?d?eCZDGd@dAdAeDZEGdBdCdCeEejFZGGdDdEdEejHeGZIGdFdGdGeIZJdtdHdIZKdJdKZLdLdMZMGdNdOdOeGZNGdPdQdQeGZOGdRdSdSeEZPdTdUZQdVdWZRGdXdYdYeCZSGdZd[d[ejTZUd\d]ZVd^d_ZWd`daZXdudbdcZYdddeZZdfdgZ[dhdiZ\djdkZ]dvdmdnZ^GdodpdpePej_ejTZ`Gdqdrdre`ZadS)wz9 Python test discovery, setup and run of test functions. )absolute_import)division)print_functionN)partial)dedent) deprecated)fixtures)nodes)filter_traceback) ascii_escaped)enum)get_default_arg_names) get_real_func) getfslineno) getimfunc) getlocation) is_generator)isclass) isfunction)NoneType)NOTSET) REGEX_TYPE) safe_getattr) safe_isclass)safe_str) STRING_TYPES)hookimpl) FSHookProxy)MARK_GEN)get_unpacked_marks)normalize_mark_list)fail)parts) PytestWarningcs(fdd}df}t|dd|S)Ncs&|ttd}|dk r"|jSdS)NZpytest) getparentgetattr __import__obj)selfnode)name-lib/python3.7/site-packages/_pytest/python.pyget3szpyobj_property..getzsP rCcCs,|jjrt|dS|jjr(t|dSdS)Nr)optionr3r8)configr+r+r,pytest_cmdline_mainss rFcCsldddg}x4|D],}|j|rd}t||jj|ddqWx&|jjddD]}|j|j|j qPWdS) NZ parameterizeZ parametriseZ parameterisez4{0} has '{1}' mark, spelling should be 'parametrize'F)pytrace parametrize)r*) definitionZget_closest_markerr!formatfunction__name__ iter_markersrHr9kwargs)metafuncZ alt_spellingsZ mark_namemsgZmarkerr+r+r,pytest_generate_tests|s   rQcCs|dd|dddS)NZmarkersaparametrize(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 https://docs.pytest.org/en/latest/parametrize.html for more info and examples.zusefixtures(fixturename1, fixturename2, ...): mark tests as needing all of the specified fixtures. see https://docs.pytest.org/en/latest/fixture.html#usefixtures )Zaddinivalue_line)rEr+r+r,pytest_configures  rRT)ZtrylastcCsP|j}|r||jn2|j}i}x|jjD]}||||<q.W|f|dS)NT)r'_isyieldedfunction_argsfuncargs _fixtureinfoargnames) pyfuncitemZ testfunctionrUZtestargsargr+r+r,pytest_pyfunc_calls  rZcCsT|j}|dkrP|j|s6t||jddgs6dS|j|}|j||dSdS)Nz.pyr;z __init__.py)pathparent)extsession isinitpathpath_matches_patternsrEgetini gethookproxypytest_pycollect_makemodule)r[r\r]ihookr+r+r,pytest_collect_files  recstfdd|DS)z^Returns True if the given py.path.local matches one of the patterns in the list of globs givenc3s|]}|VqdS)N)fnmatch).0pattern)r[r+r, sz(path_matches_patterns..)any)r[Zpatternsr+)r[r,r`sr`cCs|jdkrt||St||S)Nz __init__.py)basenamePackageModule)r[r\r+r+r,rcs  rc)Z hookwrapperccsdV}|}|dk rdSt|rB|||r@|t||dn|||rt|d|}t|stt|st |\}}t j t d|dt ||ddnnt|ddrt|rt||d}tjj|d}|tjd |d |t |nt|||}||dS) N)r\__func__z/cannot collect %r because it is not a function.)messagecategoryfilenamelineno__test__T)r*F)runreason)Z get_resultr istestclassZ force_resultClassistestfunctionr%rrrwarnings warn_explicitr#strrFunctionrZ YIELD_TESTSrJZ add_markerrZxfailwarnlist _genfunctions) collectorr*r'Zoutcomeresrrrsrvr+r+r,pytest_pycollect_makeitems2    rcCsdS)Nr+)rEvalargnamer+r+r,pytest_make_parametrize_idsrc@s$eZdZedZedZedZdS) PyobjContextrmrxInstanceN)rL __module__ __qualname__r1moduleclsinstancer+r+r+r,rsrcsTeZdZdZfddZeddZejddZddZdd d Z d d Z Z S) PyobjMixinTcstt|j||dS)N)superr__init__)r(kkw) __class__r+r,rszPyobjMixin.__init__cCs>t|dd}|dkr:||_}|jr:|jt|j|S)zUnderlying Python object._objN)r%_getobjr_ALLOW_MARKERS own_markersextendrr')r(r'r+r+r,r's  zPyobjMixin.objcCs ||_dS)N)r)r(valuer+r+r,r'scCst|jj|jS)zDGets the underlying Python object. May be overwritten by subclasses.)r%r\r'r*)r(r+r+r,rszPyobjMixin._getobjFcCs|}|g}xV|D]N}t|tr*q|j}t|tr^tj|d}|r^|r\| |P| |qW|d |}| ddS)z7 return python path relative to the containing module. r.z.[[) Z listchainreverse isinstancerr*rmosr[splitextr>joinreplace)r(Z stopatmoduleZ includemodulechainr"r)r*sr+r+r, getmodpath s"     zPyobjMixin.getmodpathcCsr|j}t|dd}t|trFtj|jj}|dr@|dd}|}n t |\}}| }t|tsht |||fS)Ncompat_co_firstlinenoz.pyc) r'r%rintsysmodulesr__file__endswithrrAssertionError)r(r'rfspathrsZmodpathr+r+r, reportinfos     zPyobjMixin.reportinfo)TF) rLrrrrr/r'setterrrr __classcell__r+r+)rr,rs   rc@sTeZdZddZddZddZddZd d Zd d Zd dZ ddZ ddZ dS) PyCollectorcCs |d|S)Nr=)_matches_prefix_or_glob_option)r(r*r+r+r,funcnamefilter0szPyCollector.funcnamefiltercCst|dddkS)zg Look for the __test__ attribute, which is applied by the @nose.tools.istest decorator rtFT)r)r(r'r+r+r, isnosetest3szPyCollector.isnosetestcCs |d|S)Nr<)r)r(r*r+r+r,classnamefilter<szPyCollector.classnamefiltercCsL||s||rDt|tr*t|dd}t|ddoBt|dkSdSdS)NrnF__call__)rrr staticmethodrrgetfixturemarker)r(r'r*r+r+r,ry?s    zPyCollector.istestfunctioncCs||p||S)N)rr)r(r'r*r+r+r,rwKszPyCollector.istestclasscCsPxJ|j|D]:}||r dSd|ks8d|ks8d|krt||rdSqWdS)zs checks if the given name matches the prefix or glob-pattern defined in ini configuration. T*?rF)rEra startswithrf)r(Z option_namer*rDr+r+r,rNs z*PyCollector._matches_prefix_or_glob_optionc Cst|jddsgSt|jdig}x"t|jjD]}||jq2Wi}g}xh|D]`}xZt|D]J\}}||krxqfd||<| ||}|dkrqft |ts|g}| |qfWqTW|j ddd|S)NrtT__dict__cSs|ddS)N)r)itemr+r+r,usz%PyCollector.collect..)key) r%r'inspectZgetmrorr>rritems _makeitemrrsort) r(ZdictsZbaseclsseenvaluesZdicr*r'rr+r+r,collect_s(   zPyCollector.collectcCs|jj|||dS)N)rr*r')rdr)r(r*r'r+r+r,rxszPyCollector._makeitemc cs&|tj}|t}|r |jp"d}|jj}t|||d}||||}t|||j ||d} g} t |drv| |j t |dr| |j | r|j j | t| dn|j j | d| jst|||dVnRt|| ||x:| jD]0} d|| jf} t| || ||| jdi|dVqWdS) N)r*r\callobj)rrrQ)rO)r\ fixtureinfoz%s[%s]T)r*r\callspecrrkeywords originalname)r$rmr'rxr^_fixturemanagerFunctionDefinitiongetfixtureinfoMetafuncrEhasattrr>rQrdZ call_extradict_callsr}rZadd_funcarg_pseudo_fixture_defZprune_dependency_treeid) r(r*funcobjrZclscolrfmrIrrOmethodsrsubnamer+r+r,r|s>      zPyCollector._genfunctionsN) rLrrrrrryrwrrrrr+r+r+r,r/s  rcs@eZdZdZddZfddZddZdd Zd d ZZ S) rmz+ Collector for test classes and functions. cCs|S)N)_importtestmodule)r(r+r+r,rszModule._getobjcs,|||jj|tt|S)N)_inject_setup_module_fixture_inject_setup_function_fixturer^rparsefactoriesrrmr)r()rr+r,rszModule.collectcs|t|jddkr t|jdt|jddkr@t|jddkrTdkrTdStjdddfd d }||j_dS) a(Injects a hidden autouse, module scoped fixture into the collected module object that invokes setUpModule/tearDownModule if either or both are available. Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with other fixtures (#517). setUpModuleN setup_moduletearDownModuleteardown_moduleTr)autousescopec3s2dk rt|jdVdk r.t|jdS)N)_call_with_optional_argumentr)request)rrr+r,xunit_setup_module_fixtures  zGModule._inject_setup_module_fixture..xunit_setup_module_fixture)_get_non_fixture_funcr'rfixtureZ_Module__pytest_setup_module)r(rr+)rrr,rs    z#Module._inject_setup_module_fixturecsTt|jdt|jddkr,dkr,dStjdddfdd}||j_dS) a0Injects a hidden autouse, function scoped fixture into the collected module object that invokes setup_function/teardown_function if either or both are available. Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with other fixtures (#517). setup_functionteardown_functionNTrK)rrc3sF|jdk rdVdSdk r(t|jdVdk rBt|jdS)N)rrrK)r)rrr+r,xunit_setup_function_fixtures  zKModule._inject_setup_function_fixture..xunit_setup_function_fixture)rr'rrZ_Module__pytest_setup_function)r(rr+)rrr,rs    z%Module._inject_setup_function_fixturec CsJ|jd}y|jj|d}Wntk rN|tjj j ddYn|jj k rt d}|d|jYntk rddlm}| }|jd d kr|jt|_|jr|j ddn|}t|}|d j|j|d Yn<tjjk r6}z|jr|d Wdd}~XYnX|jj||S)Nz --import-mode)Z ensuresyspathshort)stylerozimport 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 modulesr) ExceptionInfoverboserzImportError while importing test module '{fspath}'. Hint: make sure your test modules/packages have valid Python names. Traceback: {traceback})r tracebackzUsing pytest.skip outside of a test is not allowed. To decorate a test function, use the @pytest.mark.skip or @pytest.mark.skipif decorators instead, and to skip a module use `pytestmark = pytest.mark.{skip,skipif}.)rE getoptionrZpyimport SyntaxErrorZ CollectError_pytest_coderZ from_currentZgetreprZImportMismatchErrorrexc_infor9 ImportErrorZ_pytest._code.coderfilterr ZexconlyrrJZrunnerZSkippedZallow_module_level pluginmanagerZconsider_module)r(r?moderrZexc_reprZ formatted_tbr+r+r,rs:   zModule._importtestmodule) rLrr__doc__rrrrrrr+r+)rr,rms  rmc@sHeZdZdddZddZddZdd Zdd d Zd dZddZ dS)rlNcCs@|j}tjj||||||d|j|_|j|_|j|_||_dS)N)r\rEr^nodeid) r^r Z FSCollectorrdirnamer*Ztrace_norecursepatternsr)r(rr\rEr^rr+r+r,r#szPackage.__init__cCsxt|jd}|dkr t|jd}|dk r4t||jt|jd}|dkrTt|jd}|dk rttt||j}||dS)Nrrrr)rr'rrZ addfinalizer)r(rrfuncr+r+r,setup-s     z Package.setupcCsl|jdkrdS||}|j||jdr0dSx|jD]}|j|dr8dSq8W||}|j||ddS)N __pycache__F)r[rE)rf)r[r\T)rkrbdirpathpytest_ignore_collectrErcheckZpytest_collect_directory)r(rrdZpatr+r+r,_recurse=s    zPackage._recursecCs<|jj}||}|j|}|r0t|||}n|jj}|S)N)rErZ_getconftestmodulesZ_conftest_plugins differencerhook)r(rZpmZmy_conftestmodulesZ remove_modsproxyr+r+r,rbJs  zPackage.gethookproxyTcCs|s(td||||f||}||sP|j||jdrPdS|r|j d}|s|jj j }||krzdS| ||j |kr|gS|j||dS)Nz1%r is not a file (isdir=%r, exists=%r, islink=%r))r[rEr+keepduplicates)r[r\)isfilerisdirexistsislinkrbr_rrErrZ_duplicatepathsaddrre)r(r[Z handle_dupesrdrZduplicate_pathsr+r+r, _collectfileXs&       zPackage._collectfilecCs ||jjkS)N)r^Z _initialpaths)r(r[r+r+r,r_rszPackage.isinitpathc#s|j}|d}|jddr>t||jdr>t||Vt}x|j |j dddD] }|rj dkr|krqXt jtfdd|DrqX|rxB|D] }|VqWqXsqXqXdjddrX|qXWdS) Nz __init__.pyro)filer;T)ZrecZbfrc3s$|]}|ko|dkVqdS)z __init__.pyN)r)rgZ pkg_prefix)parts_r[r+r,risz"Package.collect..)rrrrr`rErarmsetZvisitrr rkr"Zstrpathrjrr r )r(Z this_pathZ init_moduleZ pkg_prefixesis_filexr+)rr[r,rus.       zPackage.collect)NNNN)T) rLrrrrrrbrr_rr+r+r+r,rl"s   rlcsVdk r n|t||dk rRjj}tr<|d8}|rNfddSSdS)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. NrocsS)Nr+r+) param_objresultr+r,rsz+_get_xunit_setup_teardown..)r__code__ co_argcountrismethod)ZholderZ attr_namer arg_countr+)rrr,_get_xunit_setup_teardowns   rcCs2|jj}t|r|d8}|r(||n|dS)zxCall the given function with the given argument if func accepts one argument, otherwise calls func without argumentsroN)rrrr)rrYrr+r+r,rs   rcCs"t||d}t|dkr|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'r*methr+r+r,rs rc@s(eZdZdZddZddZddZdS) rxz Collector for test methods. cCsxt|jddsgSt|jr6|td|jjgSt|jrZ|td|jjgS||t d|dgS)NrtTzBcannot collect test class %r because it has a __init__ constructorzAcannot collect test class %r because it has a __new__ constructorz())r*r\) rr'hasinitr~r#rLhasnew_inject_setup_class_fixture_inject_setup_method_fixturer)r(r+r+r,rs"  z Class.collectcsXtjdtjdddkr.dkr.dStjdddfdd}|j_dS) a&Injects a hidden autouse, class scoped fixture into the collected class object that invokes setup_class/teardown_class if either or both are available. Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with other fixtures (#517). setup_classteardown_classNTclass)rrc3sBdk rt}t|jdVdk r>t}t|jdS)N)rrr')rr)r(r r!r+r,xunit_setup_class_fixtures zDClass._inject_setup_class_fixture..xunit_setup_class_fixture)rr'r%rrZ_Class__pytest_setup_class)r(r#r+)r(r r!r,rs   z!Class._inject_setup_class_fixturecsVt|jdt|jdddkr.dkr.dStjdddfdd}||j_dS) a+Injects a hidden autouse, function scoped fixture into the collected class object that invokes setup_method/teardown_method if either or both are available. Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with other fixtures (#517). setup_methodteardown_methodNTrK)rrc3sH|j}dk r"t|d}t||dVdk rDt|d}t||dS)Nr$r%)rKr%r)r(rmethodr)r$r%r+r,xunit_setup_method_fixtures   zFClass._inject_setup_method_fixture..xunit_setup_method_fixture)rr'r%rrZ_Class__pytest_setup_method)r(r'r+)r$r%r,rs   z"Class._inject_setup_method_fixtureN)rLrrrrrrr+r+r+r,rxsrxcs0eZdZdZddZfddZddZZS)rFcCs |jS)N)r\r')r(r+r+r,rszInstance._getobjcs|jj|tt|S)N)r^rrrrr)r()rr+r,rszInstance.collectcCs||_|jS)N)rr')r(r+r+r, newinstances zInstance.newinstance)rLrrrrrr(rr+r+)rr,rs rc@s*eZdZdZddZddZd ddZdS) FunctionMixinz: mixin for the code common to Function and Generator. cCs$t|jtr |j||_dS)z' perform setup for this test function. N)rr\rr(rr')r(r+r+r,r$s  zFunctionMixin.setupcCst|dr|jjjstjt|j}|j |j }}|j }|j ||d}||krv|j |d}||krv| t}|sv|}| |_ |jjjdkrt|j dkrx |j ddD]}|dqWdS) Nr)r[ firstlineno)r[autorrorr)rrErDZ fulltracerrZCoderr'r[r*rZcutrr tbstylelenZset_repr_style)r(excinfocoder[r*rZ ntracebackentryr+r+r,_prunetraceback*s    zFunctionMixin._prunetracebackNcCs4|dkstd|jjj}|dkr&d}|j||dS)NzXXX outerr usage is deprecatedr+Zlong)r)rrErDr,Z_repr_failure_py)r(r.Zouterrrr+r+r, repr_failure?s  zFunctionMixin.repr_failure)N)rLrrrrr1r2r+r+r+r,r) sr)cCst|dd}|r|tjkSdS)Nr)r%objectr)r'Zinitr+r+r,rGs rcCst|dd}|r|tjkSdS)N__new__)r%r3r4)r'newr+r+r,rMs rc@sHeZdZddZddZddZddZed d Zd d Z d dZ dS) CallSpec2cCs:||_i|_g|_i|_t|_t|_i|_g|_i|_ dS)N) rOrU_idlistparamsr _globalid _globalparam _arg2scopenummarksindices)r(rOr+r+r,rTszCallSpec2.__init__cCspt|j}|j|j|j|j|j|j|j|j|j|jt |j |_ |j |_ |j |_ |S)N) r6rOrUupdater8r<rr=r;rr7r9r:)r(Zcsr+r+r,copy_s  zCallSpec2.copycCs&||jks||jkr"td|fdS)Nz duplicate %r)r8rU ValueError)r(rYr+r+r,_checkargnotcontainedkszCallSpec2._checkargnotcontainedcCs8y |j|Stk r2|jtkr,t||jSXdS)N)r8KeyErrorr:rr@)r(r*r+r+r,getparamos   zCallSpec2.getparamcCsdtttd|jS)N-)rmapr|rr7)r(r+r+r,rwsz CallSpec2.idc CslxJt||D]<\}} ||||} | t|| |<||j|<||j|<q W|j||jt |dS)N) ziprAr%r=r;r7r>r<rr ) r(valtypesrWZvalsetrr<scopenum param_indexrYrZvaltype_for_argr+r+r, setmulti2{s   zCallSpec2.setmulti2cCsrx|D]}||qW|j||tk r8|j||tk rT|jtksNt||_x|D]}tj |j |<qZWdS)N) rArUr>rr7r>r:rrZscopenum_functionr;)r(rUrparamrrYr+r+r,setalls    zCallSpec2.setallN) rLrrrr?rArCr/rrJrLr+r+r+r,r6Ss    r6c@s<eZdZdZdddZdddZdd Zd d Zd d ZdS)ra- Metafunc objects are passed to the :func:`pytest_generate_tests <_pytest.hookspec.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. NcCs^t|tst|jdkst||_||_||_|j|_ |j |_ ||_ g|_ t|_|j|_dS)NZDefinitionMock)rrr:rLrrIrErr'rK names_closure fixturenamesrrrZ_idsname2fixturedefs_arg2fixturedefs)r(rIrrErrr+r+r,rs zMetafunc.__init__Fc Csddlm}ddlm}|j|||j|j|jd\}}~|dkrNt||j |}| ||| ||} |j ||||jd}||d |jjd} g} xd|jpt|gD]P} xJtt||D]8\} \}}| }|| ||j||j| | | |qWqW| |_dS) 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) ParameterSet)Zfunction_definitionN)rzparametrize() call in {})Zdescr)_pytest.fixturesrQ _pytest.markrRZ_for_parametrizerKrErI_find_parametrized_scoperP_validate_if_using_arg_names_resolve_arg_value_types_resolve_arg_idsrJrLrr6 enumeraterFr?rJrr<r>)r(rWZ argvaluesindirectidsrrQrR parametersZarg_values_typesrHZnewcallsrrIZparam_idZ param_setZ newcallspecr+r+r,rHs<&    zMetafunc.parametrizec Csddlm}d}t|r |}d}|r|jj}t|t|kr^d}t||t|t|ddxB|D]:} | dk rdt| t j sdd}t|||| t | ddqdWt |||||j |d}|S) aResolves the actual ids for the given argnames, based on the ``ids`` parameter given to ``parametrize``. :param List[str] argnames: list of argument names passed to ``parametrize()``. :param ids: the ids parameter of the parametrized call (see docs). :param List[ParameterSet] parameters: the list of parameter values, same size as ``argnames``. :param Item item: the item that generated this parametrized call. :rtype: List[str] :return: the list of ids for each argname given r)safereprNzDIn {}: {} parameter sets specified, with different number of ids: {}F)rGz:In {}: ids must be list of strings, found: {} (type: {!r}))r)Z_pytest._io.safereprr]callablerKrLr-r!rJrsixZ string_typesr:idmakerrE) r(rWr[r\rr]idfn func_namerPZid_valuer+r+r,rXs$   zMetafunc._resolve_arg_idscCsi}|dkrt|d}nf|dkr0t|d}nPt|ttfrt|d}x4|D],}||krttd|jj|ddd||<qPW|S)awResolves if each parametrized argument must be considered a parameter to a fixture or a "funcarg" to the function, based on the ``indirect`` parameter of the parametrized() call. :param List[str] argnames: list of argument names passed to ``parametrize()``. :param indirect: same ``indirect`` parameter of ``parametrize()``. :rtype: Dict[str, str] A dict mapping each arg name to either: * "params" if the argname should be the parameter of a fixture of the same name. * "funcargs" if the argname should be a parameter to the parametrized test function. Tr8FrUz*In {}: indirect fixture '{}' doesn't exist)rG) rfromkeysrtuplerr!rJrKrL)r(rWrZrGrYr+r+r,rW&s     z!Metafunc._resolve_arg_value_typescCstt|j}|jj}xv|D]n}||jkr||krHtd||ddqt|tt frh||krbdnd}n |rpdnd}td|||ddqWdS)a5 Check if all argnames are being used, by default values, or directly/indirectly. :param List[str] argnames: list of argument names passed to ``parametrize()``. :param indirect: same ``indirect`` parameter of ``parametrize()``. :raise ValueError: if validation fails. zCIn {}: function already takes an argument '{}' with a default valueF)rGrZargumentzIn {}: function uses no {} '{}'N) rr rKrLrNr!rJrrdr)r(rWrZZdefault_arg_namesrbrYr*r+r+r,rVCs     z%Metafunc._validate_if_using_arg_names)NN)FNN) rLrrrrrHrXrWrVr+r+r+r,rs   R rcs|ddlm}t|ttfr,t|tk}nt|}|rx|p>i}fdd|D}|rxxt|D]}||krd|SqdWdS)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)scopescs"g|]\}}|kr|djqS)r)r)rgr* fixturedef)rWr+r, usz,_find_parametrized_scope..rK) rSrerrrdr-boolrreversed)rWZarg2fixturedefsrZreZall_arguments_are_fixtures fixturedefsZ used_scopesrr+)rWr,rUas   rUc Cs,|r|y||}|dk r|}Wqtk rx}z>d}||j||}|dt|j|7}tt||Wdd}~XYqXn|r|jj |||d} | r| St |t rt |St |t tttfrt|St |trt |jStdk rt |tjrt|St|s t|rt|dr|jSt|t|S)NzO{}: error raised while trying to determine id of parameter '{}' at position {} z {}: {} )rErrrL) ExceptionrJrr:rLr_Z raise_fromr@rrrrr floatrrhrr|rrhr Enumrrr) rridxrarrEZ generated_idrrPZhook_idr+r+r,_idvals4$     rocsj|jdk r|jS|dks0t|ks0|dkrZfddt|j|D}d|St|SdS)Nc s$g|]\}}t||dqS))rrE)ro)rgrr)rErarnrr+r,rgsz_idvalset..rD)rr-rFrrr )rn parametersetrWrar[rrEZthis_idr+)rErarnrr, _idvalsets   rqc sfddt|DtttkrfddD}tdd}x@tD]4\}} | |kr\| t|| |<|| d7<q\WS)Nc s&g|]\}}t||dqS))rEr)rq)rgZvalindexrp)rWrErar[rr+r,rgszidmaker..csg|]}|dkr|qS)ro)count)rgtestid)r[r+r,rgscSsdS)Nrr+r+r+r+r,rszidmaker..ro)rYr-r collections defaultdictr|) rWZ parametersetsrar[rEr duplicatesZcountersindexrsr+)rWrErar[rr,r`s r`cCsddlm}||tS)Nr) wrap_session) _pytest.mainrx_show_fixtures_per_test)rErxr+r+r,r8s r8csxddl}|tj|j||dfddfddfdd}x|jD] }||qdWdS) Nrrcst|}|S)N)r bestrelpath)rloc)curdirr+r,get_best_relpaths z1_show_fixtures_per_test..get_best_relpathcsx|j}dkr|drdSdkr<|j}d||}n|}j|dd|jj}|rft|njddddS)Nr_z{} -- {}T)greenz no docstring available)red)rrrrJlinerwrite_docstring)Z fixture_defrbestrel funcargspecZ fixture_doc)r~twrr+r, write_fixtures  z._show_fixtures_per_test..write_fixturecsy |j}Wntk rdSX|js*dSdd|jdd|jx8t|j D]&\}}|dk st |sqn|dqnWdS)NrDzfixtures used by {}z({})r) rVAttributeErrorrOrseprJr*rKsortedrr)rinforrj)r~rrr+r, write_items  z+_show_fixtures_per_test..write_item) _pytest.configperform_collectpyr[localrEcreate_terminal_writergetvaluer)rEr^rrZ session_itemr+)r}r~rrrr,rzs     rzcCsddlm}||tS)Nr)rx)ryrx_showfixtures_main)rErxr+r+r,r3s r3c Csddl}|tj}|j|}|d}|j}g}t }x|j D]z\} } | dk s`t | sfqLx^| D]V} t | j|} | j| f|krql|| j| f|t| j| jj|| | j| fqlWqLW|d} x|D]\}}}} } | |kr|ds||dd|f|} |dkr8| ddkr8q|dkrPd| |f}n| }|j|dd t | j|} | jjpzd }|rt||q|jd | fdd qWdS) Nrrz_pytest.rDzfixtures defined from %srz%s -- %sT)rz %s: no docstring available)r)rrrr[rrErrrrrPrrrrrr r>r-baseidrr{rrrrrr)rEr^rr}rrrZ availablerrrjrfr|Z currentmodulerrrrr0r+r+r,rsT           r cCsx|}d|kr"|dd\}}n |d}}|rF||||rtx(t|dD]}|||dqZWdS)N ror)rstripsplitstriprrwrite)rr0indent firstlinerestrr+r+r,r7s rcszeZdZdZdZdddeddddffdd ZddZedd Z d d Z ed d Z ddZ ddZ fddZZS)r}z] a Function Item is responsible for setting up and executing a Python test function. FNc sttj||||d|_|tk r,|_jjjj t j|r|_ x|j D]} | j| j<q`Wj t|j |rj|jtfddDd| dkrjjjjj d} | _| j_| _dS)N)rEr^csg|]}|jjkr|jqSr+)r*r)rgmark)r(r+r,rgusz%Function.__init__..T)rU)rr}rrTrr'rr>rrrrrr<r*r rrcrMr^rrrrSrVrMrN _initrequestr) r(r*r\r9rErrrr^rrr)r)r(r,rNs2     zFunction.__init__cCs^i|_|r"t|drNtdn,t|drN|j}|jrs                                   5   % ?}vs   N'?P!! 47 p