Current File : /usr/lib/python2.7/site-packages/google/protobuf/internal//_parameterized.pyc
�
���hc @ s` d Z d Z d d l Z d d l Z d d l Z d d l Z y d d l Z Wn e k
rk d d l Z n Xd d l Z d d l
Z
e j d � Z e j
� j Z e � Z e � Z d � Z d � Z d � Z d � Z d e f d
� � YZ d � Z d � Z d
� Z d � Z d � Z d e f d � � YZ d � Z d e j f d � � YZ! d � Z" d S( s( 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.ParameterizedTestCase):
@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 invididual test cases can be tuples (with positional parameters)
or dictionaries (with named parameters):
class AdditionExample(parameterized.ParameterizedTestCase):
@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 NamedParameters 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.ParameterizedTestCase):
@parameterized.NamedParameters(
('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
ParameterizedTestCase 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.ParameterizedTestCase):
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.ParameterizedTestCase):
@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.ParameterizedTestCase):
@parameterized.Parameters(
-1, -3, -4, -5
)
def testIsNegative(self, arg):
self.assertTrue(IsNegative(arg))
s! [email protected] (Torsten Marek)i����Ns0 \<([a-zA-Z0-9_\-\.]+) object at 0x[a-fA-F0-9]+\>c C s t j d t | � � S( Ns <\1>( t ADDR_REt subt repr( t obj( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt
_CleanRepr� s c C s d | j | j f S( Ns %s.%s( t
__module__t __name__( t cls( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt _StrClass� s c C s# t | t j � o" t | t j � S( N( t
isinstancet collectionst Iterablet sixt string_types( R ( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt _NonStringIterable� s c C sb t | t j � r/ d j d � | j � D� � St | � rQ d j t t | � � St | f � Sd S( Ns , c s s+ | ]! \ } } d | t | � f Vq d S( s %s=%sN( R ( t .0t argnamet value( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pys <genexpr>� s ( R R
t Mappingt joint itemsR t mapR t _FormatParameterList( t testcase_params( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyR � s t _ParameterizedTestIterc B s) e Z d Z d � Z d � Z d � Z RS( s9 Callable and iterable class for producing new test cases.c C s | | _ | | _ | | _ d S( s\ 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( t _test_methodt testcasest _naming_type( t selft test_methodR t naming_type( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt __init__� s c O s t d � � d S( Ns� You appear to be running a parameterized test case without having inherited from parameterized.ParameterizedTestCase. This is bad because none of your test cases are actually being run.( t RuntimeError( R t argst kwargs( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt __call__� s c s; | j � | j � � � f d � � � f d � | j D� S( Nc s� t j � � � � f d � � } � t k r\ t | _ | j t � d � 7_ � d � n8 � t k r� d t � � f | _ n t
d � f � � d | j t � � f | _ � j r� | j d � j f 7_ n | S( Nc sO t � t j � r" � | � � n) t � � r> � | � � n
� | � � d S( N( R R
R R ( R ( R R ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt BoundParamTest� s
i i s (%s)s %s is not a valid naming type.s %s(%s)s
%s( t functoolst wrapst
_FIRST_ARGt Truet __x_use_name__R t strt _ARGUMENT_REPRR t __x_extra_id__R t __doc__( R R$ ( R R ( R sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt MakeBoundParamTest� s !
c 3 s | ] } � | � Vq d S( N( ( R t c( R. ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pys <genexpr>� s ( R R R ( R ( ( R. R R sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt __iter__� s ( R R R- R R# R0 ( ( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyR � s c C s$ t | � d k o# t | d t � S( s< True iff testcases contains only a single non-tuple element.i i ( t lenR t tuple( R ( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt _IsSingletonList� s c C s� t | d d � s& t d | f � � i | _ } x� | j j � j � D]� \ } } | j t j j
� rI t | t j
� rI t | | � i } t | | | t | | | � � x- | j � D] \ } } t | | | � q� WqI qI Wd S( Nt
_id_suffixsE Cannot add parameters to %s, which already has parameterized methods.( t getattrt Nonet AssertionErrorR4 t __dict__t copyR t
startswitht unittestt
TestLoadert testMethodPrefixR t typest FunctionTypet delattrt _UpdateClassDictForParamTestCaseR t setattr( t class_objectR R t id_suffixt nameR t methodst meth( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt _ModifyClass s
"
c sK � � f d � } t � � rG t � d � s: t d � � � d � n | S( s� Implementation of the parameterization decorators.
Args:
naming_type: The naming type.
testcases: Testcase parameters.
Returns:
A function for modifying the decorated object.
c sU t | t � rA t | t � t j � s3 t � � n � � � | St | � � � Sd S( N( R t typeRH R
t Sequencet listR ( R ( R R ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt _Apply! s i s7 Single parameter argument must be a non-string iterable( R3 R R7 ( R R RL ( ( R R sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt _ParameterDecorator s
c G s
t t | � S( si 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.
( RM R+ ( R ( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt
Parameters4 s c G s
t t | � S( s� 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.
( RM R' ( R ( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt NamedParametersC s t TestGeneratorMetaclassc B s e Z d Z d � Z RS( s� 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 s� i | d <} xj | j � D]\ \ } } | j t j j � r t | � r t | � } | j | � t | | | | � q q Wt j
| | | | � S( NR4 ( R R: R; R< R= R t itert popRA RI t __new__( t mcst
class_namet basest dctRD RE R t iterator( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyRS a s
( R R R- RS ( ( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyRP T s c C s� x� t | � D]� \ } } t | � s8 t d | f � � t | d t � rV | j } n d | t | f } | | k s� t d | f � � | | | <t | d d � | | <q
Wd S( s 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.
s, Test generators must yield callables, got %rR) s %s%s%ds/ Name of parameterized test case "%s" not uniqueR, t N( t enumeratet callableR7 R5 t FalseR t
_SEPARATOR( RW RD RE RX t idxt funct new_name( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyRA m s
t ParameterizedTestCasec B s/ e Z d Z e Z d � Z d � Z d � Z RS( s9 Base class for test cases using the Parameters decorator.c C s | j j t � d S( Ni ( t _testMethodNamet splitR] ( R ( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt
_OriginalName� s c C s d | j � t | j � f S( Ns %s (%s)( Rd R t __class__( R ( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt __str__� s c C s2 d t | j � | j � | j j | j d � f S( s� 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.
s %s.%s%sRY ( R Re Rd R4 t getRb ( R ( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt id� s ( R R R- RP t
__metaclass__Rd Rf Rh ( ( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyRa � s
c C s1 t d | j t f i � } | d | t f i � S( s; Returns a new base class with a cooperative metaclass base.
This enables the ParameterizedTestCase 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.CoopParameterizedTestCase(mox.MoxTestBase)):
...
Args:
other_base_class: (class) A test case base class.
Returns:
A new class object.
t
CoopMetaclasst CoopParameterizedTestCase( RI Ri RP Ra ( t other_base_classt metaclass( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyRk � s (# R- t
__author__R
R% t reR> t unittest2R; t ImportErrort uuidR t compileR t uuid1t hexR] t objectR' R+ R R R R R R3 RH RM RN RO RI RP RA t TestCaseRa Rk ( ( ( sK /usr/lib/python2.7/site-packages/google/protobuf/internal/_parameterized.pyt <module>� s:
A 