U
|
£ý°dô= ã @ s d Z dZddlZddlZddlZddlZddlZzddlmZ W n e
|
k
|
r\ ddl Z Y nX e d¡Z e ¡ jZe Ze Zdd Zdd Zd d
|
Zd d ZG d d deZdd Zdd Zdd Zdd Z dd Z G dd de Z dd Z G d d d ej!e d Z!d d! Z"dS )"aÏ Adds support for parameterized tests to Python's unittest TestCase class.
|
|
A parameterized test is a method in a test case that is invoked with different
|
argument tuples.
|
|
A simple example:
|
|
class AdditionExample(parameterized.TestCase):
|
@parameterized.parameters(
|
(1, 2, 3),
|
(4, 5, 9),
|
(1, 1, 3))
|
def testAddition(self, op1, op2, result):
|
self.assertEqual(result, op1 + op2)
|
|
|
Each invocation is a separate test case and properly isolated just
|
like a normal test method, with its own setUp/tearDown cycle. In the
|
example above, there are three separate testcases, one of which will
|
fail due to an assertion error (1 + 1 != 3).
|
|
Parameters for individual test cases can be tuples (with positional parameters)
|
or dictionaries (with named parameters):
|
|
class AdditionExample(parameterized.TestCase):
|
@parameterized.parameters(
|
{'op1': 1, 'op2': 2, 'result': 3},
|
{'op1': 4, 'op2': 5, 'result': 9},
|
)
|
def testAddition(self, op1, op2, result):
|
self.assertEqual(result, op1 + op2)
|
|
If a parameterized test fails, the error message will show the
|
original test name (which is modified internally) and the arguments
|
for the specific invocation, which are part of the string returned by
|
the shortDescription() method on test cases.
|
|
The id method of the test, used internally by the unittest framework,
|
is also modified to show the arguments. To make sure that test names
|
stay the same across several invocations, object representations like
|
|
>>> class Foo(object):
|
... pass
|
>>> repr(Foo())
|
'<__main__.Foo object at 0x23d8610>'
|
|
are turned into '<__main__.Foo>'. For even more descriptive names,
|
especially in test logs, you can use the named_parameters decorator. In
|
this case, only tuples are supported, and the first parameters has to
|
be a string (or an object that returns an apt name when converted via
|
str()):
|
|
class NamedExample(parameterized.TestCase):
|
@parameterized.named_parameters(
|
('Normal', 'aa', 'aaa', True),
|
('EmptyPrefix', '', 'abc', True),
|
('BothEmpty', '', '', True))
|
def testStartsWith(self, prefix, string, result):
|
self.assertEqual(result, strings.startswith(prefix))
|
|
Named tests also have the benefit that they can be run individually
|
from the command line:
|
|
$ testmodule.py NamedExample.testStartsWithNormal
|
.
|
--------------------------------------------------------------------
|
Ran 1 test in 0.000s
|
|
OK
|
|
Parameterized Classes
|
=====================
|
If invocation arguments are shared across test methods in a single
|
TestCase class, instead of decorating all test methods
|
individually, the class itself can be decorated:
|
|
@parameterized.parameters(
|
(1, 2, 3)
|
(4, 5, 9))
|
class ArithmeticTest(parameterized.TestCase):
|
def testAdd(self, arg1, arg2, result):
|
self.assertEqual(arg1 + arg2, result)
|
|
def testSubtract(self, arg2, arg2, result):
|
self.assertEqual(result - arg1, arg2)
|
|
Inputs from Iterables
|
=====================
|
If parameters should be shared across several test cases, or are dynamically
|
created from other sources, a single non-tuple iterable can be passed into
|
the decorator. This iterable will be used to obtain the test cases:
|
|
class AdditionExample(parameterized.TestCase):
|
@parameterized.parameters(
|
c.op1, c.op2, c.result for c in testcases
|
)
|
def testAddition(self, op1, op2, result):
|
self.assertEqual(result, op1 + op2)
|
|
|
Single-Argument Test Methods
|
============================
|
If a test method takes only one argument, the single argument does not need to
|
be wrapped into a tuple:
|
|
class NegativeNumberExample(parameterized.TestCase):
|
@parameterized.parameters(
|
-1, -3, -4, -5
|
)
|
def testIsNegative(self, arg):
|
self.assertTrue(IsNegative(arg))
|
z!tmarek@google.com (Torsten Marek)é Nz0\<([a-zA-Z0-9_\-\.]+) object at 0x[a-fA-F0-9]+\>c C s t dt| ¡S )Nz<\1>)ÚADDR_REÚsubÚrepr©Úobj© r ú^d:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\google/protobuf/internal/_parameterized.pyÚ
|
_CleanRepr§ s r c C s d| j | jf S )Nz%s.%s)Ú
|
__module__Ú__name__)Úclsr r r Ú _StrClass s r c C s t | tjot | t S ©N)Ú
|
isinstanceÚcollections_abcÚIterableÚstrr r r r Ú_NonStringIterable± s
|
ÿr c C sJ t | tjr$d dd | ¡ D ¡S t| r<d tt| ¡S t| fS d S )Nz, c s s" | ]\}}d |t |f V qdS )z%s=%sN)r )Ú.0ÚargnameÚvaluer r r Ú <genexpr>¸ s ÿz'_FormatParameterList.<locals>.<genexpr>) r r ÚMappingÚjoinÚitemsr Úmapr Ú_FormatParameterList©Útestcase_paramsr r r r ¶ s
|
ÿr c @ s( e Zd ZdZdd Zdd Zdd ZdS ) Ú_ParameterizedTestIterz9Callable and iterable class for producing new test cases.c C s || _ || _|| _dS )a\ Returns concrete test functions for a test and a list of parameters.
|
|
The naming_type is used to determine the name of the concrete
|
functions as reported by the unittest framework. If naming_type is
|
_FIRST_ARG, the testcases must be tuples, and the first element must
|
have a string representation that is a valid Python identifier.
|
|
Args:
|
test_method: The decorated test method.
|
testcases: (list of tuple/dict) A list of parameter
|
tuples/dicts for individual test invocations.
|
naming_type: The test naming type, either _NAMED or _ARGUMENT_REPR.
|
N)Ú _test_methodÚ testcasesÚ _naming_type)ÚselfÚ test_methodr! Ú naming_typer r r Ú__init__Ã s z _ParameterizedTestIter.__init__c O s t dd S )Nz¬You appear to be running a parameterized test case without having inherited from parameterized.TestCase. This is bad because none of your test cases are actually being run.)Ú RuntimeError)r# ÚargsÚkwargsr r r Ú__call__Õ s z _ParameterizedTestIter.__call__c s. | j | jfdd fdd| jD S )Nc s¦ t ¡ fdd}tkrJd|_| jt d 7 _ dd
n(tkrddt f |_nt df d|jt f |_
|
j
|
r¢| j
|
d j
|
f 7 _
|
|S )
|
Nc s@ t tjr | f n"tr2 | f n
|
| d S r )r r r r ©r# )r$ r r r ÚBoundParamTestà s
|
zS_ParameterizedTestIter.__iter__.<locals>.MakeBoundParamTest.<locals>.BoundParamTestTr é z(%s)z %s is not a valid naming type.z%s(%s)z
|
%s) Ú functoolsÚwrapsÚ
|
_FIRST_ARGÚ__x_use_name__r r Ú_ARGUMENT_REPRr Ú__x_extra_id__r' Ú__doc__)r r, )r% r$ r r ÚMakeBoundParamTestß s$ ÿ
|
ÿz;_ParameterizedTestIter.__iter__.<locals>.MakeBoundParamTestc 3 s | ]} |V qd S r r )r Úc)r5 r r r þ s z2_ParameterizedTestIter.__iter__.<locals>.<genexpr>)r r" r! r+ r )r5 r% r$ r Ú__iter__Û s z _ParameterizedTestIter.__iter__N)r r
|
Ú __qualname__r4 r& r* r7 r r r r r À s r c C s t | dkot| d t S )z<True iff testcases contains only a single non-tuple element.r- r )Úlenr Útuple©r! r r r Ú_IsSingletonList s r< c C s t | dd rtd| f i | _}| j ¡ ¡ D ]d\}}| tjj ¡r2t
|
|t j r2t | | i }t|||t||| | ¡ D ]\}}t| || qq2d S )NÚ
|
_id_suffixzECannot add parameters to %s, which already has parameterized methods.)ÚgetattrÚAssertionErrorr= Ú__dict__Úcopyr Ú
|
startswithÚunittestÚ
|
TestLoaderÚtestMethodPrefixr ÚtypesÚ FunctionTypeÚdelattrÚ _UpdateClassDictForParamTestCaser Úsetattr)Z class_objectr! r% Ú id_suffixÚnamer ÚmethodsÚmethr r r Ú _ModifyClass s( ÿÿ
|
|
ÿ
|
|
þrO c s6 fdd}t r2td s*tdd |S )zÃImplementation of the parameterization decorators.
|
|
Args:
|
naming_type: The naming type.
|
testcases: Testcase parameters.
|
|
Returns:
|
A function for modifying the decorated object.
|
c s> t | tr.t| t tjs"tn | S t| S d S r )r ÚtyperO r ÚSequenceÚlistr r ©r% r! r r Ú_Apply# s
|
üz#_ParameterDecorator.<locals>._Applyr z7Single parameter argument must be a non-string iterable)r< r r? )r% r! rT r rS r Ú_ParameterDecorator s
|
ÿrU c G s
|
t t| S )ai A decorator for creating parameterized tests.
|
|
See the module docstring for a usage example.
|
Args:
|
*testcases: Parameters for the decorated method, either a single
|
iterable, or a list of tuples/dicts/objects (for tests
|
with only one argument).
|
|
Returns:
|
A test generator to be handled by TestGeneratorMetaclass.
|
)rU r2 r; r r r Ú
|
parameters6 s rV c G s
|
t t| S )a A decorator for creating parameterized tests.
|
|
See the module docstring for a usage example. The first element of
|
each parameter tuple should be a string and will be appended to the
|
name of the test method.
|
|
Args:
|
*testcases: Parameters for the decorated method, either a single
|
iterable, or a list of tuples.
|
|
Returns:
|
A test generator to be handled by TestGeneratorMetaclass.
|
)rU r0 r; r r r Únamed_parametersE s rW c @ s e Zd ZdZdd ZdS )ÚTestGeneratorMetaclassaì Metaclass for test cases with test generators.
|
|
A test generator is an iterable in a testcase that produces callables. These
|
callables must be single-argument methods. These methods are injected into
|
the class namespace and the original iterable is removed. If the name of the
|
iterable conforms to the test pattern, the injected methods will be picked
|
up as tests by the unittest framework.
|
|
In general, it is supposed to be used in conjunction with the
|
parameters decorator.
|
c C sh i |d< }| ¡ ¡ D ]>\}}| tjj¡rt|rt|}| |¡ t |||| qt
|
| |||¡S )Nr= ) rA r rB rC rD rE r ÚiterÚpoprI rP Ú__new__)ZmcsÚ
|
class_nameÚbasesÚdctrK rL r Úiteratorr r r r[ c s ÿ
|
z TestGeneratorMetaclass.__new__N)r r
|
r8 r4 r[ r r r r rX V s rX c C s| t |D ]n\}}t|s&td|f t|ddr:|j}nd|t|f }|| ks^td|f || |< t|dd||< qdS ) a Adds individual test cases to a dictionary.
|
|
Args:
|
dct: The target dictionary.
|
id_suffix: The dictionary for mapping names to test IDs.
|
name: The original name of the test case.
|
iterator: The iterator generating the individual test cases.
|
z,Test generators must yield callables, got %rr1 Fz%s%s%dz/Name of parameterized test case "%s" not uniquer3 Ú N)Ú enumerateÚcallabler? r> r Ú
|
_SEPARATOR)r^ rK rL r_ ÚidxÚfuncÚnew_namer r r rI o s ÿ
|
ÿrI c @ s( e Zd ZdZdd Zdd Zdd ZdS ) ÚTestCasez9Base class for test cases using the parameters decorator.c C s | j t¡d S )Nr )Ú_testMethodNameÚsplitrc r+ r r r Ú _OriginalName s zTestCase._OriginalNamec C s d| ¡ t| jf S )Nz%s (%s))rj r Ú __class__r+ r r r Ú__str__ s zTestCase.__str__c C s$ dt | j| ¡ | j | jd¡f S )z½Returns the descriptive ID of the test.
|
|
This is used internally by the unittesting framework to get a name
|
for the test to be used in reports.
|
|
Returns:
|
The test id.
|
z%s.%s%sr` )r rk rj r= Úgetrh r+ r r r Úid s
|
þz TestCase.idN)r r
|
r8 r4 rj rl rn r r r r rg
s rg )Ú metaclassc C s" t d| jtfi }|d| tfi S )a! Returns a new base class with a cooperative metaclass base.
|
|
This enables the TestCase to be used in combination
|
with other base classes that have custom metaclasses, such as
|
mox.MoxTestBase.
|
|
Only works with metaclasses that do not override type.__new__.
|
|
Example:
|
|
import google3
|
import mox
|
|
from google3.testing.pybase import parameterized
|
|
class ExampleTest(parameterized.CoopTestCase(mox.MoxTestBase)):
|
...
|
|
Args:
|
other_base_class: (class) A test case base class.
|
|
Returns:
|
A new class object.
|
Z CoopMetaclassÚ CoopTestCase)rP Ú __metaclass__rX rg )Zother_base_classro r r r rp s ÿý þrp )#r4 Ú
|
__author__r. ÚrerF rC ÚuuidÚcollections.abcÚabcr Ú ImportErrorÚ collectionsÚcompiler Úuuid1Úhexrc Úobjectr0 r2 r r r r r r< rO rU rV rW rP rX rI rg rp r r r r Ú<module>! s8 q
|
|
|
A
|
