o Zc@sdZddlmZddlmZddlmZmZm Z GdddeZ GdddeZ Gd d d eZ Gd d d eZ Gd ddeZdS)z& Tests for various Pyflakes behavior. ) version_info)messages)TestCaseskipskipIfc@s<eZdZddZddZeedkdddZd d Zd d Z d dZ ddZ ddZ ddZ ddZddZddZddZddZdd Zeedkdd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Z d;d<Z!d=d>Z"eed?kd@dAdBZ#eed?kd@dCdDZ$dEdFZ%dGdHZ&eedIkdJdKdLZ'dMdNZ(dOdPZ)dQdRZ*dSdTZ+eedkdUdVdWZ,eedkdUdXdYZ-e.dZd[d\Z/d]d^Z0d_d`Z1dadbZ2dcddZ3dedfZ4dgdhZ5didjZ6dkdlZ7dmdnZ8dodpZ9dqdrZ:dsdtZ;eed?kd@dudvZz$Test.test_classNameDefinedPreviouslycCr)zW If a class is defined twice in the same module, a warning is emitted. zQ class Foo: pass class Foo: pass Nr r rrrtest_classRedefinitionJzTest.test_classRedefinitioncCr)zN If a function is redefined as a class, a warning is emitted. zQ def Foo(): pass class Foo: pass Nr r rrrtest_functionRedefinedAsClassUr@z"Test.test_functionRedefinedAsClasscCr)zN If a class is redefined as a function, a warning is emitted. zQ class Foo: pass def Foo(): pass Nr r rrrtest_classRedefinedAsFunction`r@z"Test.test_classRedefinedAsFunctioncCr)zK If a return is used inside a class, a warning is emitted. z7 class Foo(object): return Nr r ReturnOutsideFunctionr rrrtest_classWithReturnkr)zTest.test_classWithReturncCr)zP If a return is used at the module level, a warning is emitted. z return NrCr rrrtest_moduleWithReturntzTest.test_moduleWithReturncCr)zJ If a yield is used inside a class, a warning is emitted. z6 class Foo(object): yield Nr r YieldOutsideFunctionr rrrtest_classWithYield|r)zTest.test_classWithYieldcCr)zO If a yield is used at the module level, a warning is emitted. z yield NrHr rrrtest_moduleWithYieldrGzTest.test_moduleWithYieldrrzPython >= 3.3 onlycCr)zO If a yield from is used inside a class, a warning is emitted. zE class Foo(object): yield from range(10) NrHr rrrtest_classWithYieldFromr#zTest.test_classWithYieldFromcCr)zT If a yield from is used at the module level, a warning is emitted. z& yield from range(10) NrHr rrrtest_moduleWithYieldFromszTest.test_moduleWithYieldFromcCsX|dtj|dtj|dtj|dtj|dtj|dtjdS)Nz continue z/ def f(): continue zQ while True: pass else: continue z while True: pass else: if 1: if 2: continue zK while True: def f(): continue zK while True: class A: continue )r r ContinueOutsideLoopr rrrtest_continueOutsideLoops$ zTest.test_continueOutsideLoopcCs@|d|d|d|d|d|ddS)Nz2 while True: continue z: for i in range(10): continue zH while True: if 1: continue zP for i in range(10): if 1: continue z while True: while True: pass else: continue else: pass z while True: try: pass finally: while True: continue r%r rrrtest_continueInsideLoops      zTest.test_continueInsideLooprPython <= 3.8 onlycCs.|dtj|dtj|dtjdS)Nzq while True: try: pass finally: continue z while True: try: pass finally: if 1: if 2: continue zM try: pass finally: continue r r ContinueInFinallyr rrrtest_continueInFinallys zTest.test_continueInFinallycCsf|dtj|dtj|dtj|dtj|dtj|dtj|dtjdS)Nz break z, def f(): break zN while True: pass else: break z~ while True: pass else: if 1: if 2: break zH while True: def f(): break zH while True: class A: break zJ try: pass finally: break )r r BreakOutsideLoopr rrrtest_breakOutsideLoops* zTest.test_breakOutsideLoopcCsT|d|d|d|d|d|d|d|ddS) Nz/ while True: break z7 for i in range(10): break zE while True: if 1: break zM for i in range(10): if 1: break z while True: while True: pass else: break else: pass z while True: try: pass finally: while True: break zn while True: try: pass finally: break z while True: try: pass finally: if 1: if 2: break r%r rrrtest_breakInsideLoop;s      zTest.test_breakInsideLoopcCs@|d|d|d|d|d|ddS)a# A default except block should be last. YES: try: ... except Exception: ... except: ... NO: try: ... except: ... except Exception: ... zS try: pass except ValueError: pass zt try: pass except ValueError: pass except: pass zH try: pass except: pass zr try: pass except ValueError: pass else: pass zg try: pass except: pass else: pass z try: pass except ValueError: pass except: pass else: pass Nr%r rrrtest_defaultExceptLastws     zTest.test_defaultExceptLastcCs|dtj|dtj|dtj|dtjtj|dtj|dtj|dtj|dtjtj|d tj|d tj|d tj|d tjtj|d tj|dtj|dtj|dtjtjdS)Nzt try: pass except: pass except ValueError: pass zi try: pass except: pass except: pass z try: pass except: pass except ValueError: pass except: pass z try: pass except: pass except ValueError: pass except: pass except ValueError: pass z try: pass except: pass except ValueError: pass else: pass z try: pass except: pass except: pass else: pass z try: pass except: pass except ValueError: pass except: pass else: pass z try: pass except: pass except ValueError: pass except: pass except ValueError: pass else: pass z try: pass except: pass except ValueError: pass finally: pass z try: pass except: pass except: pass finally: pass z try: pass except: pass except ValueError: pass except: pass finally: pass z try: pass except: pass except ValueError: pass except: pass except ValueError: pass finally: pass z try: pass except: pass except ValueError: pass else: pass finally: pass z try: pass except: pass except: pass else: pass finally: pass z try: pass except: pass except ValueError: pass except: pass else: pass finally: pass a try: pass except: pass except ValueError: pass except: pass except ValueError: pass else: pass finally: pass )r r DefaultExceptNotLastr rrrtest_defaultExceptNotLasts`                         zTest.test_defaultExceptNotLastz Python 3 onlycCs|d|d|d|d|d|d|d|d|d d d d td Dd}||dd dd td Dd}||dd dd td Dd}||dS)z6 Python 3 extended iterable unpacking z# a, *b = range(10) z# *a, b = range(10) z& a, *b, c = range(10) z% (a, *b) = range(10) z% (*a, b) = range(10) z( (a, *b, c) = range(10) z% [a, *b] = range(10) z% [*a, b] = range(10) z( [a, *b, c] = range(10) , cs|]}d|VqdSza%dNr.0irrr z5Test.test_starredAssignmentNoError..z, *rest = range(1<<8)(csr_r`rrarrrrdrez, *rest) = range(1<<8)[csr_r`rrarrrrdrez, *rest] = range(1<<8)N)r joinranger srrrtest_starredAssignmentNoErrors*           z"Test.test_starredAssignmentNoErrorcCsdddtdDd}||tjddddtdDd}||tjd dd dtdDd }||tjdd dtd Dd}||tjddddtd Dd}||tjd dddtd Dd}||tj|dtj|dtj|dtj|dtj|dtj|dtj|dtj|dtj|dtjdS)zp SyntaxErrors (not encoded in the ast) surrounding Python 3 extended iterable unpacking r^csr_r`rrarrrrdrez4Test.test_starredAssignmentErrors..z, *rest = range(1<<8 + 1)rgcsr_r`rrarrrrdrez, *rest) = range(1<<8 + 1)rhcsr_r`rrarrrrdrez, *rest] = range(1<<8 + 1)csr_r`rrarrrrdreiz, *rest = range(1<<8 + 2)csr_r`rrarrrrdrez, *rest) = range(1<<8 + 2)csr_r`rrarrrrdrez, *rest] = range(1<<8 + 2)z' a, *b, *c = range(10) z* a, *b, c, *d = range(10) z( *a, *b, *c = range(10) z) (a, *b, *c) = range(10) z, (a, *b, c, *d) = range(10) z* (*a, *b, *c) = range(10) z) [a, *b, *c] = range(10) z, [a, *b, c, *d] = range(10) z* [*a, *b, *c] = range(10) N)rirjr r %TooManyExpressionsInStarredAssignmentTwoStarredExpressionsrkrrrtest_starredAssignmentErrorssfz!Test.test_starredAssignmentErrorsz= y x > y Nr%r rrrtest_comparison)r'zTest.test_comparisoncCr$)zn If a defined name is used on either side of an identity test, no warning is emitted. zI x = 10 y = 20 x is y x is not y Nr%r rrr test_identity9r'zTest.test_identitycCr$)zp If a defined name is used on either side of a containment test, no warning is emitted. zI x = 10 y = 20 x in y x not in y Nr%r rrrtest_containmentEr'zTest.test_containmentcCs|d|ddS)z> break and continue statements are supported. z4 for x in [1, 2]: break z7 for x in [1, 2]: continue Nr%r rrrtest_loopControlQs zTest.test_loopControlcCr$)z3 Ellipsis in a slice is supported. z [1, 2][...] Nr%r rrr test_ellipsis^zTest.test_ellipsiscCr$)z0 Extended slices are supported. z+ x = 3 [1, 2][x,:] Nr%r rrrtest_extendedSlicefrzzTest.test_extendedSlicecCr$)zh Augmented assignment of a variable is supported. We don't care about var refs. z* foo = 0 foo += 1 Nr%r rrrtest_varAugmentedAssignmentor'z Test.test_varAugmentedAssignmentcCr$)zi Augmented assignment of attributes is supported. We don't care about attr refs. z7 foo = None foo.bar += foo.baz Nr%r rrrtest_attrAugmentedAssignmentyr'z!Test.test_attrAugmentedAssignmentcCr$)zP A 'global' can be declared in one scope and reused in another. zV def f(): global foo def g(): foo = 'anything'; foo.is_used() Nr%r rrr#test_globalDeclaredInDifferentScoperzz(Test.test_globalDeclaredInDifferentScopecCs,|d|d|d|ddS)z; Test to traverse ARG and ARGUMENT handler z1 def foo(a, b): pass z6 def foo(a, b, c=0): pass z= def foo(a, b, c=0, *args): pass zG def foo(a, b, c=0, *args, **kwargs): pass Nr%r rrrtest_function_argumentss   zTest.test_function_argumentscCr4)NzL def foo(a, b, c=0, *args, d=0, **kwargs): pass r%r rrrtest_function_arguments_python3r8z$Test.test_function_arguments_python3N)=__name__ __module__ __qualname__rrrrrrrrr"r&r(r*r,r-r.r/r0r1r2r3r5r7r;r<r=r?rArBrErFrJrKrMrNrPrQrWrYrZr[r]rmrqrrrrsrtrurvrwrxryr{r|r}r~rrrrrrr s                        & * -<J J  5 G           rc@seZdZdZddZddZddZdd Zed d d Z d dZ ddZ e e dkdddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Z d9d:Z!d;d<Z"d=d>Z#d?d@Z$dAdBZ%dCdDZ&dEdFZ'dGdHZ(dIdJZ)dKdLZ*dMdNZ+dOdPZ,e e dkdQdRdSZ-dTdUZ.dVdWZ/dXdYZ0dZd[Z1d\d]Z2d^d_Z3d`daZ4dbdcZ5dddeZ6e e dfkdgdhdiZ7e e djkdkdldmZ8e e dnkdodpdqZ9drS)sTestUnusedAssignmentz5 Tests for warning about unused assignments. cCr)zc Warn when a variable in a function is assigned a value that's never used. z, def a(): b = 1 Nrr rrrtest_unusedVariabler#z(TestUnusedAssignment.test_unusedVariablecCr$)zh Don't warn when the magic "_" (underscore) variable is unused. See issue #202. zC def a(unused_param): _ = unused_param Nr%r rrrtest_unusedUnderscoreVariabler'z2TestUnusedAssignment.test_unusedUnderscoreVariablecCr$)zO Using locals() it is perfectly valid to have unused variables zH def a(): b = 1 return locals() Nr%r rrrtest_unusedVariableAsLocalsrzz0TestUnusedAssignment.test_unusedVariableAsLocalscCr)zA Using locals() in wrong scope should not matter zq def a(): locals() def a(): b = 1 return Nrr rrrtest_unusedVariableNoLocalssz0TestUnusedAssignment.test_unusedVariableNoLocalszAtodo: Difficult because it doesn't apply in the context of a loopcCr)zV Shadowing a used variable can still raise an UnusedVariable warning. zR def a(): b = 1 b.foo() b = 2 Nrr rrrtest_unusedReassignedVariablez2TestUnusedAssignment.test_unusedReassignedVariablecCr$)zt Shadowing a used variable cannot raise an UnusedVariable warning in the context of a loop. z^ def a(): b = True while b: b = False Nr%r rrrtest_variableUsedInLoopr'z,TestUnusedAssignment.test_variableUsedInLoopcCr$)z Assigning to a global and then not using that global is perfectly acceptable. Do not mistake it for an unused local variable. zO b = 0 def a(): global b b = 1 Nr%r rrrtest_assignToGlobalr'z(TestUnusedAssignment.test_assignToGlobalrznew in Python 3cCr$)z Assigning to a nonlocal and then not using that binding is perfectly acceptable. Do not mistake it for an unused local variable. zW b = b'0' def a(): nonlocal b b = b'1' Nr%r rrrtest_assignToNonlocalr>z*TestUnusedAssignment.test_assignToNonlocalcCr$)z Assigning to a member of another object and then not using that member variable is perfectly acceptable. Do not mistake it for an unused local variable. zR class b: pass def a(): b.foo = 1 Nr%r rrrtest_assignToMember z(TestUnusedAssignment.test_assignToMembercCr$)zW Don't warn when a variable in a for loop is assigned to but not used. zO def f(): for i in range(10): pass Nr%r rrrtest_assignInForLooprzz)TestUnusedAssignment.test_assignInForLoopcCr$)zi Don't warn when a variable in a list comprehension is assigned to but not used. z@ def f(): [None for i in range(10)] Nr%r rrrtest_assignInListComprehension%r'z3TestUnusedAssignment.test_assignInListComprehensioncCr$)zk Don't warn when a variable in a generator expression is assigned to but not used. z@ def f(): (None for i in range(10)) Nr%r rrrtest_generatorExpression/r'z-TestUnusedAssignment.test_generatorExpressioncCr$)zW Don't warn when a variable assignment occurs lexically after its use. z def f(): x = None for i in range(10): if i > 2: return x x = i * 2 Nr%r rrrtest_assignmentInsideLoop9rzz.TestUnusedAssignment.test_assignmentInsideLoopcCsF|d|dtjtj|d|dtj|dtjdS)z Don't warn when a variable included in tuple unpacking is unused. It's very common for variables in a tuple unpacking assignment to be unused in good Python code, so warning will only create false positives. z6 def f(tup): (x, y) = tup z4 def f(): (x, y) = 1, 2 zq def f(): (x, y) = coords = 1, 2 if x > 1: print(coords) z= def f(): (x, y) = coords = 1, 2 z= def f(): coords = (x, y) = 1, 2 Nrr rrrtest_tupleUnpackingFs  z(TestUnusedAssignment.test_tupleUnpackingcCs |d|dtjtjdS)zR Don't warn when a variable included in list unpacking is unused. z6 def f(tup): [x, y] = tup z6 def f(): [x, y] = [1, 2] Nrr rrrtest_listUnpackingcs z'TestUnusedAssignment.test_listUnpackingcCr$)zN Don't warn when the assignment is used in an inner function. z~ def barMaker(): foo = 5 def bar(): return foo return bar Nr%r rrrtest_closedOverprzz$TestUnusedAssignment.test_closedOvercCr$)z Don't warn when the assignment is used in an inner function, even if that inner function itself is in an inner function. z def barMaker(): foo = 5 def bar(): def baz(): return foo return bar Nr%r rrrtest_doubleClosedOver|r'z*TestUnusedAssignment.test_doubleClosedOvercCr$)z} Do not warn about unused local variable __tracebackhide__, which is a special variable for py.test. zL def helper(): __tracebackhide__ = True Nr%r rrr!test_tracebackhideSpecialVariabler'z6TestUnusedAssignment.test_tracebackhideSpecialVariablecCs*|d|dtj|dtjdS)z9 Test C{foo if bar else baz} statements. za = 'moo' if True else 'oink'za = foo if True else 'oink'za = 'moo' if True else barNr9r rrr test_ifexps zTestUnusedAssignment.test_ifexpcCs4|d|d|dtj|dtjdS)z/ Test C{if (foo,)} conditions. z if (): passzC if ( True ): pass zD if ( True, ): pass z? x = 1 if ( True, ) else 2 N)r r IfTupler rrr test_if_tuples  z"TestUnusedAssignment.test_if_tuplecCr$)z No warnings are emitted for using inside or after a nameless C{with} statement a name defined beforehand. z from __future__ import with_statement bar = None with open("foo"): bar bar Nr%r rrrtest_withStatementNoNamesr'z.TestUnusedAssignment.test_withStatementNoNamescCr$)z No warnings are emitted for using a name defined by a C{with} statement within the suite or afterwards. zt from __future__ import with_statement with open('foo') as bar: bar bar Nr%r rrrtest_withStatementSingleNamer'z1TestUnusedAssignment.test_withStatementSingleNamecCr$)zn No warnings are emitted for using an attribute as the target of a C{with} statement. z from __future__ import with_statement import foo with open('foo') as foo.bar: pass Nr%r rrrtest_withStatementAttributeNamer'z4TestUnusedAssignment.test_withStatementAttributeNamecCr$)zm No warnings are emitted for using a subscript as the target of a C{with} statement. z from __future__ import with_statement import foo with open('foo') as foo[0]: pass Nr%r rrrtest_withStatementSubscriptr'z0TestUnusedAssignment.test_withStatementSubscriptcCr)z An undefined name warning is emitted if the subscript used as the target of a C{with} statement is not defined. z from __future__ import with_statement import foo with open('foo') as foo[bar]: pass Nr9r rrr$test_withStatementSubscriptUndefinedrz9TestUnusedAssignment.test_withStatementSubscriptUndefinedcCr$)z No warnings are emitted for using any of the tuple of names defined by a C{with} statement within the suite or afterwards. z from __future__ import with_statement with open('foo') as (bar, baz): bar, baz bar, baz Nr%r rrrtest_withStatementTupleNamesr'z1TestUnusedAssignment.test_withStatementTupleNamescCr$)z No warnings are emitted for using any of the list of names defined by a C{with} statement within the suite or afterwards. z from __future__ import with_statement with open('foo') as [bar, baz]: bar, baz bar, baz Nr%r rrrtest_withStatementListNamesr'z0TestUnusedAssignment.test_withStatementListNamescCr$)aq If the target of a C{with} statement uses any or all of the valid forms for that part of the grammar (See U{http://docs.python.org/reference/compound_stmts.html#the-with-statement}), the names involved are checked both for definedness and any bindings created are respected in the suite of the statement and afterwards. z from __future__ import with_statement c = d = e = g = h = i = None with open('foo') as [(a, b), c[d], e.f, g[h:i]]: a, b, c, d, e, g, h, i a, b, c, d, e, g, h, i Nr%r rrr#test_withStatementComplicatedTargetrz8TestUnusedAssignment.test_withStatementComplicatedTargetcCr)z An undefined name warning is emitted if the name first defined by a C{with} statement is used before the C{with} statement. zu from __future__ import with_statement bar with open('foo') as bar: pass Nr9r rrr%test_withStatementSingleNameUndefinedrz:TestUnusedAssignment.test_withStatementSingleNameUndefinedcCr)z An undefined name warning is emitted if a name first defined by the tuple-unpacking form of the C{with} statement is used before the C{with} statement. z| from __future__ import with_statement baz with open('foo') as (bar, baz): pass Nr9r rrr%test_withStatementTupleNamesUndefined$z:TestUnusedAssignment.test_withStatementTupleNamesUndefinedcCr)z A redefined name warning is emitted if a name bound by an import is rebound by the name defined by a C{with} statement. z| from __future__ import with_statement import bar with open('foo') as bar: pass Nr r rrr%test_withStatementSingleNameRedefined1rz:TestUnusedAssignment.test_withStatementSingleNameRedefinedcCr)z A redefined name warning is emitted if a name bound by an import is rebound by one of the names defined by the tuple-unpacking form of a C{with} statement. z from __future__ import with_statement import bar with open('foo') as (bar, baz): pass Nr r rrr%test_withStatementTupleNamesRedefined=rz:TestUnusedAssignment.test_withStatementTupleNamesRedefinedcCr)z An undefined name warning is emitted if a name is used inside the body of a C{with} statement without first being bound. zh from __future__ import with_statement with open('foo') as bar: baz Nr9r rrr!test_withStatementUndefinedInsideJr+z6TestUnusedAssignment.test_withStatementUndefinedInsidecCr$)z| A name defined in the body of a C{with} statement can be used after the body ends without warning. zy from __future__ import with_statement with open('foo') as bar: baz = 10 baz Nr%r rrr#test_withStatementNameDefinedInBodyUr'z8TestUnusedAssignment.test_withStatementNameDefinedInBodycCs |dtj|dtjdS)z An undefined name warning is emitted if a name in the I{test} expression of a C{with} statement is undefined. za from __future__ import with_statement with bar as baz: pass za from __future__ import with_statement with bar as bar: pass Nr9r rrr'test_withStatementUndefinedInExpressionas zz5TestUnusedAssignment.test_exceptWithoutNameInFunctioncCr$)z Don't issue false warning when an unnamed exception is used. This example catches a tuple of exception types. z import tokenize def foo(): try: pass except (tokenize.TokenError, IndentationError): pass Nr%r rrr%test_exceptWithoutNameInFunctionTupler'z:TestUnusedAssignment.test_exceptWithoutNameInFunctionTuplecCr$)zt Consider a function that is called on the right part of an augassign operation to be used. zJ from foo import bar baz = 0 baz += bar() Nr%r rrr,test_augmentedAssignmentImportedFunctionCallr'zATestUnusedAssignment.test_augmentedAssignmentImportedFunctionCallcCr$)z,An assert without a message is not an error.z( a = 1 assert a Nr%r rrrtest_assert_without_messager8z0TestUnusedAssignment.test_assert_without_messagecCr$)z)An assert with a message is not an error.z- a = 1 assert a, 'x' Nr%r rrrtest_assert_with_messager8z-TestUnusedAssignment.test_assert_with_messagecCs|dtjtjdS)z.An assert of a non-empty tuple is always True.z> assert (False, 'x') assert (False, ) N)r r AssertTupler rrrtest_assert_tuplesz&TestUnusedAssignment.test_assert_tuplecCr$)z,An assert of an empty tuple is always False.z assert () Nr%r rrrtest_assert_tuple_emptyr8z,TestUnusedAssignment.test_assert_tuple_emptycCr$)z,An assert of a static value is not an error.z. assert True assert 1 Nr%r rrrtest_assert_staticr8z'TestUnusedAssignment.test_assert_staticrLznew in Python 3.3cCr)z. Test C{yield from} statement z9 def bar(): yield from foo() Nr9r rrrtest_yieldFromUndefinedr#z,TestUnusedAssignment.test_yieldFromUndefinedrnew in Python 3.6cCr$)z.Test PEP 498 f-strings are treated as a usage.z3 baz = 0 print(f'{4*baz}') Nr%r rrr test_f_stringz"TestUnusedAssignment.test_f_stringrRznew in Python 3.8cCr$)zATest PEP 572 assignment expressions are treated as usage / write.zJ from foo import y print(x := y) print(x) Nr%r rrrtest_assign_exprrz%TestUnusedAssignment.test_assign_exprN):rrr__doc__rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsz                                     rc@sHeZdZeedkdddZddZddZeed kd d d Zd S)TestStringFormattingrrcCsZ|dtj|dtj|dtj|dtj|d|d|ddS)Nzf'foo'z= f"""foo bar """ zX print( f'foo' f'bar' ) zf'{{}}'z5 x = 5 print(f'{x}') z? x = 'a' * 90 print(f'{x:.8}') zC x = y = 5 print(f'{x:>2} {y:>2}') )r r FStringMissingPlaceholdersr rrr"test_f_string_without_placeholderss  z7TestStringFormatting.test_f_string_without_placeholderscCs|dtj|dtj|dtj|dtj|dtj|dtj|dtj|dtj|d tj|d |d |d |d |d|d|ddS)Nz# '{'.format(1) z+ '{} {1}'.format(1, 2) z+ '{0} {}'.format(1, 2) z' '{}'.format(1, 2) z+ '{}'.format(1, bar=2) z' '{} {}'.format(1) z$ '{2}'.format() z& '{bar}'.format() z0 '{:{:{}}}'.format(1, 2, 3) z'{.__class__}'.format('')z('{foo[bar]}'.format(foo={'bar': 'barv'})z8 print('{:{}} {}'.format(1, 15, 2)) z- print('{:2}'.format(1)) z1 '{foo}-{}'.format(1, foo=2) z8 a = () "{}".format(*a) z< k = {} "{foo}".format(**k) )r r StringDotFormatInvalidFormatStringDotFormatMixingAutomatic'StringDotFormatExtraPositionalArguments"StringDotFormatExtraNamedArgumentsStringDotFormatMissingArgumentr rrrtest_invalid_dot_format_calls"sD      z2TestStringFormatting.test_invalid_dot_format_callscCs|dtj|dtj|dtj|dtj|dtj|dtj|dtj|dtj|d tj|d tj |d tj |d |d |d|ddS)Nz/ '%(foo)' % {'foo': 'bar'} z3 '%s %(foo)s' % {'foo': 'bar'} z3 '%(foo)s %s' % {'foo': 'bar'} z! '%j' % (1,) z$ '%s %s' % (1,) z) '%s %s' % (1, 2, 3) z$ '%(bar)s' % {} z6 '%(bar)s' % {'bar': 1, 'baz': 2} z+ '%(bar)s' % (1, 2, 3) z* '%s %s' % {'k': 'v'} z1 '%(bar)*s' % {'bar': 'baz'} z: '%s' % {'foo': 'bar', 'baz': 'womp'} z+ "%1000000000000f" % 1 z, '%% %s %% %s' % (1, 2) zO '%.*f' % (2, 1.1234) '%*.*f' % (5, 2, 3.1234) ) r r PercentFormatInvalidFormat$PercentFormatMixedPositionalAndNamed'PercentFormatUnsupportedFormatCharacter$PercentFormatPositionalCountMismatchPercentFormatMissingArgument PercentFormatExtraNamedArgumentsPercentFormatExpectedMappingPercentFormatExpectedSequence!PercentFormatStarRequiresSequencer rrr!test_invalid_percent_format_callsXsJ   z6TestStringFormatting.test_invalid_percent_format_callsrnew in Python 3.5cCr)NzS a = [] '%s %s' % [*a] '%s %s' % (*a,) z8 k = {} '%(k)s' % {**k} r%r rrr5test_ok_percent_format_cannot_determine_element_counts zJTestStringFormatting.test_ok_percent_format_cannot_determine_element_countN) rrrrrrrrrrrrrrs  6 4rc@s*eZdZeedkdddZeedkdddZeedkdddZeedkdd d Zeedkdd d Z eedkdd dZ eedkdddZ eedkdeedkdddZ eedkdddZ eedkdddZeedkdddZeedkdddZdd Zd!S)"TestAsyncStatementsrrcCr4)Nz8 async def bar(): return 42 r%r rrr test_asyncDefr8z!TestAsyncStatements.test_asyncDefcCr4)NzS async def read_data(db): await db.fetch('SELECT ...') r%r rrrtest_asyncDefAwaitr8z&TestAsyncStatements.test_asyncDefAwaitcCr)Nz; async def bar(): return foo() r9r rrrtest_asyncDefUndefinedsz*TestAsyncStatements.test_asyncDefUndefinedcCr4)Nz async def read_data(db): output = [] async for row in db.cursor(): output.append(row) return output r%r rrr test_asyncForr8z!TestAsyncStatements.test_asyncForcCr4)NzY async def coro(it): async for _ in it: pass r%r rrrtest_asyncForUnderscoreLoopVarr8z2TestAsyncStatements.test_asyncForUnderscoreLoopVarcCr)Nz async def read_data(db): output = [] async for row in db.cursor(): if row[0] == 'skip': continue output.append(row) return output z async def read_data(db): output = [] async for row in db.cursor(): if row[0] == 'stop': break output.append(row) return output r%r rrrtest_loopControlInAsyncFors  z.TestAsyncStatements.test_loopControlInAsyncForcCs |dtj|dtjdS)Nz async def read_data(db): output = [] async for row in db.cursor(): output.append(row) else: continue return output z async def read_data(db): output = [] async for row in db.cursor(): output.append(row) else: break return output )r r rOrXr rrrtest_loopControlInAsyncForElses  z2TestAsyncStatements.test_loopControlInAsyncForElserRrTcCr)Nz async def read_data(db): output = [] async for row in db.cursor(): try: output.append(row) finally: continue return output rUr rrrtest_continueInAsyncForFinallys z2TestAsyncStatements.test_continueInAsyncForFinallycCr4)Nz async def commit(session, data): async with session.transaction(): await session.update(data) r%r rrrtest_asyncWithr8z"TestAsyncStatements.test_asyncWithcCr4)Nz async def commit(session, data): async with session.transaction() as trans: await trans.begin() ... await trans.end() r%r rrrtest_asyncWithItemr8z&TestAsyncStatements.test_asyncWithItemcCr4)Nz9 def foo(a, b): return a @ b r%r rrr test_matmulr8zTestAsyncStatements.test_matmulrrcCr4)NzE hi = 'hi' mom = 'mom' f'{hi} {mom}' r%r rrrtest_formatstringr8z%TestAsyncStatements.test_formatstringcCs4|d|d|dtj|dtjdS)Nz; raise NotImplementedError("This is fine") z+ raise NotImplementedError z? raise NotImplemented("This isn't gonna work") z& raise NotImplemented )r r RaiseNotImplementedr rrrtest_raise_notimplementeds  z-TestAsyncStatements.test_raise_notimplementedN)rrrrrrrrrrrrrrrrrrrrrrrs6                       rc@s@eZdZdZddZddZddZdd Zd d Zd d Z dS)TestIncompatiblePrintOperatorz@ Tests for warning about invalid use of print function. cCr4)Nz print("Hello") r%r rrrtest_valid_print4r6z.TestIncompatiblePrintOperator.test_valid_printcCs4|dtjjd}||jd||jddS)Nzn from __future__ import print_function import sys print >>sys.stderr, "Hello" r)r r InvalidPrintSyntaxr assertEquallinenocol)r excrrr,test_invalid_print_when_imported_from_future9szJTestIncompatiblePrintOperator.test_invalid_print_when_imported_from_futurecCr$)zJ A valid assignment, tested for catching false positives. z` from __future__ import print_function log = print log("Hello") Nr%r rrrtest_print_function_assignmentCrzzs0  *X