U
|
P ±dÌ@ ã @ sÌ d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z ddl
|
m Z e ddZ G d d de Z d
|
d Zd d dZdd Zdd ZdadaedddddgZddiZdd Zd d ZG d d d ZdS )!an
|
tl;dr: all code is licensed under simplified BSD, unless stated otherwise.
|
|
Unless stated otherwise in the source files, all code is copyright 2010 David
|
Wolever <david@wolever.net>. All rights reserved.
|
|
Redistribution and use in source and binary forms, with or without
|
modification, are permitted provided that the following conditions are met:
|
|
1. Redistributions of source code must retain the above copyright notice,
|
this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright notice,
|
this list of conditions and the following disclaimer in the documentation
|
and/or other materials provided with the distribution.
|
|
THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND ANY EXPRESS OR
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
EVENT SHALL <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
|
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
The views and conclusions contained in the software and documentation are those
|
of the authors and should not be interpreted as representing official policies,
|
either expressed or implied, of David Wolever.
|
|
é N)Úwraps)Ú
|
MethodType)Ú
|
namedtuple)ÚTestCaseÚparamz args kwargsc @ s: e Zd ZdZdd Zed ddZedd Zd d
|
ZdS ) r aÞ Represents a single parameter to a test case.
|
|
For example::
|
|
>>> p = param("foo", bar=16)
|
>>> p
|
param("foo", bar=16)
|
>>> p.args
|
('foo', )
|
>>> p.kwargs
|
{'bar': 16}
|
|
Intended to be used as an argument to ``@parameterized``::
|
|
@parameterized([
|
param("foo", bar=16),
|
])
|
def test_stuff(foo, bar=16):
|
pass
|
c O s t | ||¡S ©N)Ú_paramÚ__new__©ÚclsÚargsÚkwargs© r ú[d:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/testing/_private/parameterized.pyr B s z param.__new__Nc C s |pd}|pi }| ||S )a Creates a ``param`` by explicitly specifying ``args`` and
|
``kwargs``::
|
|
>>> param.explicit([1,2,3])
|
param(*(1, 2, 3))
|
>>> param.explicit(kwargs={"foo": 42})
|
param(*(), **{"foo": "42"})
|
r r r
|
r r r ÚexplicitE s
|
zparam.explicitc
|
C sp t |tr|S t |tfr |f}z
|
| | W S tk
|
rj } z"dt|krJ td||f W 5 d}~X Y nX dS )a( Returns an instance of ``param()`` for ``@parameterized`` argument
|
``args``::
|
|
>>> param.from_decorator((42, ))
|
param(args=(42, ), kwargs={})
|
>>> param.from_decorator("foo")
|
param(args=("foo", ), kwargs={})
|
zafter * must bez=Parameters must be tuples, but %r is not (hint: use '(%r, )')N)Ú
|
isinstancer ÚstrÚ TypeError)r r Úer r r Úfrom_decoratorS s
|
|
|
ÿÿzparam.from_decoratorc C s d| S )Nzparam(*%r, **%r)r )Úselfr r r Ú__repr__k s zparam.__repr__)NN) Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r Ú classmethodr r r r r r r r , s
|
c sø t | ¡}|jdd
dgkr"dnd}|j|d
}tt| j}|jt|| d
} jt|d
}| fddt||jpg D ¡ dd |D tt fd d j
|
D }|rÚ| d
|
|j f t |f¡ |rô| d |jf |f¡ |S ) a Return tuples of parameterized arguments and their values.
|
|
This is useful if you are writing your own doc_func
|
function and need to know the values for each parameter name::
|
|
>>> def func(a, foo=None, bar=42, **kwargs): pass
|
>>> p = param(1, foo=7, extra=99)
|
>>> parameterized_argument_value_pairs(func, p)
|
[("a", 1), ("foo", 7), ("bar", 42), ("**kwargs", {"extra": 99})]
|
|
If the function's first argument is named ``self`` then it will be
|
ignored::
|
|
>>> def func(self, a): pass
|
>>> p = param(1)
|
>>> parameterized_argument_value_pairs(func, p)
|
[("a", 1)]
|
|
Additionally, empty ``*args`` or ``**kwargs`` will be ignored::
|
|
>>> def func(foo, *args): pass
|
>>> p = param(1)
|
>>> parameterized_argument_value_pairs(func, p)
|
[("foo", 1)]
|
>>> p = param(1, 16)
|
>>> parameterized_argument_value_pairs(func, p)
|
[("foo", 1), ("*args", (16, ))]
|
Né r r c s" g | ]\}}| j ||¡fqS r )r Úget)Ú.0ÚnameÚdefault)Úpr r Ú
|
<listcomp> s ÿz6parameterized_argument_value_pairs.<locals>.<listcomp>c S s h | ] \}}|qS r r )r ÚnÚ_r r r Ú <setcomp> s z5parameterized_argument_value_pairs.<locals>.<setcomp>c s" g | ]}|kr| j | fqS r )r )r r ©r" Zseen_arg_namesr r r# s þz*%sz**%s)ÚinspectÚ
|
getargspecr ÚlistÚzipÚlenÚextendÚdefaultsÚdictÚsortedr ÚappendÚvarargsÚtupleÚkeywords)Úfuncr" ZargspecZ
|
arg_offsetZ
|
named_argsÚresultr2 r4 r r' r Ú"parameterized_argument_value_pairso s$
|
ýþ
|
r7 é@ c C s| t | }t|tr@zt|d}W n tk
|
r> t|d}Y nX t||krx|d|d
d |t||d d
}|S )zÁ A shortened repr of ``x`` which is guaranteed to be ``unicode``::
|
|
>>> short_repr("foo")
|
u"foo"
|
>>> short_repr("123456789", n=4)
|
u"12...89"
|
zutf-8Úlatin1Né z...)Úreprr Úbytesr ÚUnicodeDecodeErrorr, )Úxr$ Zx_reprr r r Ú
|
short_reprª s
|
,r? c
|
C s | j d krd S t| |}dd |D }| j ¡ d¡\}}}d}| d¡rZd}|d d
}dt|rhdpjdd |¡f } d | ¡ | |||g¡S )
|
Nc S s" g | ]\}}| d t | qS )ú=)r? )r r$ Úvr r r r# Ä s z$default_doc_func.<locals>.<listcomp>Ú
|
Ú Ú.éÿÿÿÿz %s[with %s]ú ú, )r r7 ÚlstripÚ partitionÚendswithr, ÚjoinÚrstrip)
|
r5 Únumr" Zall_args_with_valuesZdescsÚfirstÚnlÚrestÚsuffixr r r r Údefault_doc_func½ s
|
|
|
rR c C sP | j }d|f }t|jdkrHt|jd tfrH|dt |jd ¡ 7 }|| S )Nz_%sr r% )r r, r r r Ú parameterizedÚ to_safe_name)r5 rM r" Ú base_nameZ name_suffixr r r Údefault_name_funcÑ s
|
|
rV ZnoseFÚunittestZ unittest2Znose2ZpytestZ_pytestc C s& | t kr td| d t ¡f | ad S )Nz,Invalid test runner: %r (must be one of: %s)rG )Ú _test_runnersr rK Ú_test_runner_override)r r r r Úset_test_runnerá s ÿÿrZ c C sp t dk r t S tdkrlt ¡ } t| D ]B}|d }|j d¡ d¡d }|tkrVt| }|t kr$|a qlq$datS )a
|
Guess which test runner we're using by traversing the stack and looking
|
for the first matching module. This *should* be reasonably safe, as
|
it's done during test discovery where the test runner should be the
|
stack frame immediately outside. NFr r rD )
|
rY Ú_test_runner_guessr( ÚstackÚreversedÚ f_globalsr rI Ú_test_runner_aliasesrX )r\ ÚrecordÚframeÚmoduler r r Ú detect_runnerê s rc c @ sx e Zd ZdZdddZdd Zdd Zd d
|
Zd d Ze d d Z
|
e dd Z e dddZ e dd Z e dd ZdS )rS a= Parameterize a test case::
|
|
class TestInt:
|
@parameterized([
|
("A", 10),
|
("F", 15),
|
param("10", 42, base=42)
|
])
|
def test_int(self, input, expected, base=16):
|
actual = int(input, base=base)
|
assert_equal(actual, expected)
|
|
@parameterized([
|
(2, 3, 5)
|
(3, 5, 8),
|
])
|
def test_add(a, b, expected):
|
assert_equal(a + b, expected)
|
Nc C s | |¡| _|pt| _d S r )Úinput_as_callableÚ get_inputrR Údoc_func)r Úinputrf r r r Ú__init__ s zparameterized.__init__c sD ¡ td fdd ¡ __djf _S )Nc
|
3 s | o
|
t | }j}tjD ]p\}}t |¡} | ||¡\}}z,|d j_| d k rft |j| |V W 5 | d k rt|j |_X q d S )Nr )
|
Útyper Ú enumerateÚparameterized_inputr r Úparam_as_nose_tupleÚdelattrr Úsetattr)Ú test_selfZtest_clsZ original_docrM r r" Ú unbound_funcZ
|
nose_tuple©r Ú test_funcÚwrapperr r rs s
|
|
z'parameterized.__call__.<locals>.wrapperz_parameterized_original_%s)N)Ú assert_not_in_testcase_subclassr re rk Zparameterized_funcr )r rr r rq r Ú__call__ s
|
zparameterized.__call__c sV t fdd}| ||¡|_|}|d k r:t||}||f|j |jpNi f fS )Nc s | d d
| d S )NrE r )r ©r5 r r Ú<lambda>8 ó z3parameterized.param_as_nose_tuple.<locals>.<lambda>)r rf r r r r )r ro r5 rM r" Z nose_funcrp r rv r rl 7 s
|
z!parameterized.param_as_nose_tuplec C s& | ¡ }tdd |D r"tdd S )Nc s s | ]}t |tV qd S r )Ú
|
issubclassr )r r r r r Ú <genexpr>D s z@parameterized.assert_not_in_testcase_subclass.<locals>.<genexpr>zqWarning: '@parameterized' tests won't work inside subclasses of 'TestCase' - use '@parameterized.expand' instead.)Ú$_terrible_magic_get_defining_classesÚanyÚ Exception)r Zparent_classesr r r rt B s z-parameterized.assert_not_in_testcase_subclassc C s t ¡ }t|dkrg S |d }|d o6|d d ¡ }|rF| d¡sJg S | d¡\}}}| d¡\}}}td| d |d j|d jS )a@ Returns the list of parent classes of the class currently being defined.
|
Will likely only work if called from the ``parameterized`` decorator.
|
This function is entirely @brandon_rhodes's fault, as he suggested
|
the implementation: http://stackoverflow.com/a/8793684/71522
|
é r zclass ú(ú)ú[ú]) r( r\ r, ÚstripÚ
|
startswithrI Úevalr^ Úf_locals)r r\ ra Ú code_contextr% Úparentsr r r r{ I s z2parameterized._terrible_magic_get_defining_classesc s, t r fddS ¡fddS )Nc s ¡S r )Úcheck_input_valuesr ©r rg r r rw ] rx z1parameterized.input_as_callable.<locals>.<lambda>c s S r r r )Ú input_valuesr r rw _ rx )Úcallabler r r )r rg r r rd Z s
|
z parameterized.input_as_callablec C s t |tst|}dd |D S )Nc S s g | ]}t |¡qS r )r r )r r" r r r r# j s z4parameterized.check_input_values.<locals>.<listcomp>)r r* )r r r r r r a s
|
z parameterized.check_input_valuesc sp d|kr$t jdtdd s$|d d|krHt jdtdd sH|d pNtpVtd
|
fdd }|S ) am A "brute force" method of parameterizing test cases. Creates new
|
test cases and injects them into the namespace that the wrapped
|
function is being defined in. Useful for parameterizing tests in
|
subclasses of 'UnitTest', where Nose test generators don't work.
|
|
>>> @parameterized.expand([("foo", 1, 2)])
|
... def test_add1(name, input, expected):
|
... actual = add1(input)
|
... assert_equal(actual, expected)
|
...
|
>>> locals()
|
... 'test_add1_foo_0': <function ...> ...
|
>>>
|
Ztestcase_func_namez1testcase_func_name= is deprecated; use name_func=r: )Ú
|
stacklevelZtestcase_func_docz/testcase_func_doc= is deprecated; use doc_func=Nc sr t ¡ }|d }|d j} ¡ }t|D ]8\}}| ||} || |¡||< | |||| _q.d| _d S )Nr r F)r( r\ r rd rj Úparam_as_standalone_funcr Z__test__) ÚfÚinstancer\ ra Z frame_localsÚ
|
parametersrM r" r ©r rf rg Ú name_funcr r Ú parameterized_expand_wrapper s
|
z:parameterized.expand.<locals>.parameterized_expand_wrapper)N)ÚwarningsÚwarnÚDeprecationWarningrR rV )r rg r rf Úlegacyr r r r Úexpandl s$ ÿ ÿ zparameterized.expandc sD t fdd}||_ |_z|`W n tk
|
r> Y nX |S )Nc s | j jS r )r r )Úa©r5 r" r r Ústandalone_func s z?parameterized.param_as_standalone_func.<locals>.standalone_func)r r Zplace_asÚ __wrapped__ÚAttributeError)r r" r5 r r r r r r s z¶meterized.param_as_standalone_funcc C s t t dd|¡S )Nz[^a-zA-Z0-9_]+r% )r ÚreÚsub)r Úsr r r rT ® s zparameterized.to_safe_name)N)NN)r r r r rh ru rl rt r{ r rd r r r rT r r r r rS s
|
|
|
|
-
|
rS )r8 )r r r( r Ú functoolsr Útypesr Ú collectionsr rW r r r r7 r? rR rV rY r[ ÚsetrX r_ rZ rc rS r r r r Ú<module> s,
|
C;
|
ÿ
|
