B >¶†\"½ã@stdZddlmZddlmZddlmZmZm Z Gdd„deƒZ Gdd„deƒZ Gd d „d eƒZ Gd d „d eƒZ d S)z& Tests for various Pyflakes behavior. é)Ú version_info)Úmessages)ÚTestCaseÚskipÚskipIfc@s.eZdZdd„Zdd„Zeedkdƒdd„ƒZd d „Zd d „Z d d„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Zdd „Zeedkdƒd!d"„ƒZd#d$„Zd%d&„Zd'd(„Zd)d*„Zd+d,„Zd-d.„Zd/d0„Zd1d2„Zd3d4„Zd5d6„Zd7d8„Zd9d:„Z d;d<„Z!d=d>„Z"eed?kd@ƒdAdB„ƒZ#eed?kd@ƒdCdD„ƒZ$dEdF„Z%dGdH„Z&dIdJ„Z'dKdL„Z(dMdN„Z)dOdP„Z*dQdR„Z+eedkdSƒdTdU„ƒZ,eedkdSƒdVdW„ƒZ-e.dXƒdYdZ„ƒZ/d[d\„Z0d]d^„Z1d_d`„Z2dadb„Z3dcdd„Z4dedf„Z5dgdh„Z6didj„Z7dkdl„Z8dmdn„Z9dodp„Z:dqdr„Z;eed?kd@ƒdsdt„ƒZsz$Test.test_classNameDefinedPreviouslycCs| dtj¡dS)zW If a class is defined twice in the same module, a warning is emitted. zQ class Foo: pass class Foo: pass N)rr r)r r r r Útest_classRedefinitionJszTest.test_classRedefinitioncCs| dtj¡dS)zN If a function is redefined as a class, a warning is emitted. zQ def Foo(): pass class Foo: pass N)rr r)r r r r Útest_functionRedefinedAsClassUsz"Test.test_functionRedefinedAsClasscCs| dtj¡dS)zN If a class is redefined as a function, a warning is emitted. zQ class Foo: pass def Foo(): pass N)rr r)r r r r Útest_classRedefinedAsFunction`sz"Test.test_classRedefinedAsFunctioncCs| dtj¡dS)zK If a return is used inside a class, a warning is emitted. z7 class Foo(object): return N)rr ÚReturnOutsideFunction)r r r r Útest_classWithReturnkszTest.test_classWithReturncCs| dtj¡dS)zP If a return is used at the module level, a warning is emitted. z return N)rr r,)r r r r Útest_moduleWithReturntszTest.test_moduleWithReturncCs| dtj¡dS)zJ If a yield is used inside a class, a warning is emitted. z6 class Foo(object): yield N)rr ÚYieldOutsideFunction)r r r r Útest_classWithYield|szTest.test_classWithYieldcCs| dtj¡dS)zO If a yield is used at the module level, a warning is emitted. z yield N)rr r/)r r r r Útest_moduleWithYield…szTest.test_moduleWithYield)rrzPython >= 3.3 onlycCs| dtj¡dS)zO If a yield from is used inside a class, a warning is emitted. zE class Foo(object): yield from range(10) N)rr r/)r r r r Útest_classWithYieldFromszTest.test_classWithYieldFromcCs| dtj¡dS)zT If a yield from is used at the module level, a warning is emitted. z& yield from range(10) N)rr r/)r r r r Útest_moduleWithYieldFrom—szTest.test_moduleWithYieldFromcCsX| dtj¡| dtj¡| dtj¡| dtj¡| dtj¡| dtj¡dS)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 )rr ÚContinueOutsideLoop)r r r r Útest_continueOutsideLoop s     zTest.test_continueOutsideLoopcCs@| d¡| d¡| d¡| d¡| d¡| d¡dS)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 r r r Útest_continueInsideLoopÆszTest.test_continueInsideLoopcCs.| dtj¡| dtj¡| dtj¡dS)Nzq while True: try: pass finally: continue z© while True: try: pass finally: if 1: if 2: continue zM try: pass finally: continue )rr ÚContinueInFinally)r r r r Útest_continueInFinallyðs   zTest.test_continueInFinallycCsf| dtj¡| dtj¡| dtj¡| dtj¡| dtj¡| dtj¡| dtj¡dS)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 )rr ÚBreakOutsideLoop)r r r r Útest_breakOutsideLoop s      zTest.test_breakOutsideLoopcCsT| d¡| d¡| d¡| d¡| d¡| d¡| d¡| d¡dS) 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 r r r Útest_breakInsideLoop9s zTest.test_breakInsideLoopcCs@| d¡| d¡| d¡| d¡| d¡| d¡dS)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 N)r)r r r r Útest_defaultExceptLastus zTest.test_defaultExceptLastcCsô| dtj¡| dtj¡| dtj¡| dtjtj¡| dtj¡| dtj¡| dtj¡| dtjtj¡| d tj¡| d tj¡| d tj¡| d tjtj¡| d tj¡| dtj¡| dtj¡| dtjtj¡dS)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 )rr ZDefaultExceptNotLast)r r r r Útest_defaultExceptNotLast¿s@               zTest.test_defaultExceptNotLastz Python 3 onlycCsØ| d¡| d¡| d¡| d¡| d¡| d¡| d¡| d¡| d ¡d  d d „td ƒDƒ¡d}| |¡dd  dd „td ƒDƒ¡d}| |¡dd  dd „td ƒDƒ¡d}| |¡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) z, css|]}d|VqdS)za%dNr )Ú.0Úir r r ú ²sz5Test.test_starredAssignmentNoError..é€z, *rest = range(1<<8)ú(css|]}d|VqdS)za%dNr )r>r?r r r r@¶sz, *rest) = range(1<<8)ú[css|]}d|VqdS)za%dNr )r>r?r r r r@ºsz, *rest] = range(1<<8)N)rÚjoinÚrange)r Úsr r r Útest_starredAssignmentNoErrorˆs6  z"Test.test_starredAssignmentNoErrorcCsŽd dd„tdƒDƒ¡d}| |tj¡dd dd„tdƒDƒ¡d}| |tj¡d d d d„tdƒDƒ¡d }| |tj¡d d d„td ƒDƒ¡d}| |tj¡dd dd„td ƒDƒ¡d}| |tj¡d d dd„td ƒDƒ¡d}| |tj¡| dtj¡| dtj¡| dtj¡| dtj¡| dtj¡| dtj¡| dtj¡| dtj¡| dtj¡dS)zp SyntaxErrors (not encoded in the ast) surrounding Python 3 extended iterable unpacking z, css|]}d|VqdS)za%dNr )r>r?r r r r@Åsz4Test.test_starredAssignmentErrors..éz, *rest = range(1<<8 + 1)rBcss|]}d|VqdS)za%dNr )r>r?r r r r@Ész, *rest) = range(1<<8 + 1)rCcss|]}d|VqdS)za%dNr )r>r?r r r r@Ísz, *rest] = range(1<<8 + 1)css|]}d|VqdS)za%dNr )r>r?r r r r@Ñsiz, *rest = range(1<<8 + 2)css|]}d|VqdS)za%dNr )r>r?r r r r@Õsz, *rest) = range(1<<8 + 2)css|]}d|VqdS)za%dNr )r>r?r r r r@Ùsz, *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)rDrErr Z%TooManyExpressionsInStarredAssignmentZTwoStarredExpressions)r rFr r r Útest_starredAssignmentErrors¾sH        z!Test.test_starredAssignmentErrorsz= y x > y N)r)r r r r Útest_comparison's zTest.test_comparisoncCs| d¡dS)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 N)r)r r r r Ú test_identity7szTest.test_identitycCs| d¡dS)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 N)r)r r r r Útest_containmentCszTest.test_containmentcCs| d¡| d¡dS)z> break and continue statements are supported. z4 for x in [1, 2]: break z7 for x in [1, 2]: continue N)r)r r r r Útest_loopControlOszTest.test_loopControlcCs| d¡dS)z3 Ellipsis in a slice is supported. z [1, 2][...] N)r)r r r r Ú test_ellipsis\szTest.test_ellipsiscCs| d¡dS)z0 Extended slices are supported. z+ x = 3 [1, 2][x,:] N)r)r r r r Útest_extendedSlicedszTest.test_extendedSlicecCs| d¡dS)zh Augmented assignment of a variable is supported. We don't care about var refs. z* foo = 0 foo += 1 N)r)r r r r Útest_varAugmentedAssignmentmsz Test.test_varAugmentedAssignmentcCs| d¡dS)zi Augmented assignment of attributes is supported. We don't care about attr refs. z7 foo = None foo.bar += foo.baz N)r)r r r r Útest_attrAugmentedAssignmentwsz!Test.test_attrAugmentedAssignmentcCs| d¡dS)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() N)r)r r r r Ú#test_globalDeclaredInDifferentScopesz(Test.test_globalDeclaredInDifferentScopecCs,| d¡| d¡| d¡| d¡dS)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 N)r)r r r r Útest_function_argumentsŠszTest.test_function_argumentscCs| d¡dS)NzL def foo(a, b, c=0, *args, d=0, **kwargs): pass )r)r r r r Útest_function_arguments_python3¢sz$Test.test_function_arguments_python3N)=Ú__name__Ú __module__Ú __qualname__r rrrrrrrrrrrrrrrrr r!r"r#r$r&r'r(r)r*r+r-r.r0r1r2r3r5r6r8r:r;r<r=rGrIrrJrKrLrMrNrOrPrQrRrSrTrUrVrWr r r r r st                     &*-<JJ6H          rc@sØeZdZdZdd„Zdd„Zdd„Zdd „Zed ƒd d „ƒZ d d„Z dd„Z e e dkdƒdd„ƒZdd„Zdd„Zdd„Zdd„Zdd„Zdd „Zd!d"„Zd#d$„Zd%d&„Zd'd(„Zd)d*„Zd+d,„Zd-d.„Zd/d0„Zd1d2„Zd3d4„Zd5d6„Zd7d8„Z d9d:„Z!d;d<„Z"d=d>„Z#d?d@„Z$dAdB„Z%dCdD„Z&dEdF„Z'dGdH„Z(dIdJ„Z)dKdL„Z*dMdN„Z+e e dkdOƒdPdQ„ƒZ,dRdS„Z-dTdU„Z.dVdW„Z/dXdY„Z0dZd[„Z1d\d]„Z2d^d_„Z3d`da„Z4dbdc„Z5e e ddkdeƒdfdg„ƒZ6e e dhkdiƒdjdk„ƒZ7dlS)mÚTestUnusedAssignmentz5 Tests for warning about unused assignments. cCs| dtj¡dS)zc Warn when a variable in a function is assigned a value that's never used. z, def a(): b = 1 N)rr r)r r r r Útest_unusedVariable¯sz(TestUnusedAssignment.test_unusedVariablecCs| d¡dS)zh Don't warn when the magic "_" (underscore) variable is unused. See issue #202. zC def a(unused_param): _ = unused_param N)r)r r r r Útest_unusedUnderscoreVariable¹sz2TestUnusedAssignment.test_unusedUnderscoreVariablecCs| d¡dS)zO Using locals() it is perfectly valid to have unused variables zH def a(): b = 1 return locals() N)r)r r r r Útest_unusedVariableAsLocalsÃsz0TestUnusedAssignment.test_unusedVariableAsLocalscCs| dtj¡dS)zA Using locals() in wrong scope should not matter zq def a(): locals() def a(): b = 1 return N)rr r)r r r r Útest_unusedVariableNoLocalsÍsz0TestUnusedAssignment.test_unusedVariableNoLocalszAtodo: Difficult because it doesn't apply in the context of a loopcCs| dtj¡dS)zV Shadowing a used variable can still raise an UnusedVariable warning. zR def a(): b = 1 b.foo() b = 2 N)rr r)r r r r Útest_unusedReassignedVariableÙsz2TestUnusedAssignment.test_unusedReassignedVariablecCs| d¡dS)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 N)r)r r r r Útest_variableUsedInLoopåsz,TestUnusedAssignment.test_variableUsedInLoopcCs| d¡dS)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 N)r)r r r r Útest_assignToGlobalñsz(TestUnusedAssignment.test_assignToGlobal)rznew in Python 3cCs| d¡dS)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' N)r)r r r r Útest_assignToNonlocalýsz*TestUnusedAssignment.test_assignToNonlocalcCs| d¡dS)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 N)r)r r r r Útest_assignToMember sz(TestUnusedAssignment.test_assignToMembercCs| d¡dS)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 N)r)r r r r Útest_assignInForLoopsz)TestUnusedAssignment.test_assignInForLoopcCs| d¡dS)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)] N)r)r r r r Útest_assignInListComprehension#sz3TestUnusedAssignment.test_assignInListComprehensioncCs| d¡dS)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)) N)r)r r r r Útest_generatorExpression-sz-TestUnusedAssignment.test_generatorExpressioncCs| d¡dS)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 N)r)r r r r Útest_assignmentInsideLoop7sz.TestUnusedAssignment.test_assignmentInsideLoopcCsF| d¡| dtjtj¡| d¡| dtj¡| dtj¡dS)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 N)rr r)r r r r Útest_tupleUnpackingDs z(TestUnusedAssignment.test_tupleUnpackingcCs | d¡| dtjtj¡dS)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] N)rr r)r r r r Útest_listUnpackingasz'TestUnusedAssignment.test_listUnpackingcCs| d¡dS)zN Don't warn when the assignment is used in an inner function. z~ def barMaker(): foo = 5 def bar(): return foo return bar N)r)r r r r Útest_closedOvernsz$TestUnusedAssignment.test_closedOvercCs| d¡dS)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 N)r)r r r r Útest_doubleClosedOverzsz*TestUnusedAssignment.test_doubleClosedOvercCs| d¡dS)z} Do not warn about unused local variable __tracebackhide__, which is a special variable for py.test. zL def helper(): __tracebackhide__ = True N)r)r r r r Ú!test_tracebackhideSpecialVariableˆsz6TestUnusedAssignment.test_tracebackhideSpecialVariablecCs*| d¡| dtj¡| dtj¡dS)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 barN)rr r%)r r r r Ú test_ifexp’s zTestUnusedAssignment.test_ifexpcCs| d¡dS)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 N)r)r r r r Útest_withStatementNoNamesšsz.TestUnusedAssignment.test_withStatementNoNamescCs| d¡dS)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 N)r)r r r r Útest_withStatementSingleName§sz1TestUnusedAssignment.test_withStatementSingleNamecCs| d¡dS)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 N)r)r r r r Útest_withStatementAttributeName³sz4TestUnusedAssignment.test_withStatementAttributeNamecCs| d¡dS)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 N)r)r r r r Útest_withStatementSubscript¿sz0TestUnusedAssignment.test_withStatementSubscriptcCs| dtj¡dS)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 N)rr r%)r r r r Ú$test_withStatementSubscriptUndefinedËsz9TestUnusedAssignment.test_withStatementSubscriptUndefinedcCs| d¡dS)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 N)r)r r r r Útest_withStatementTupleNames×sz1TestUnusedAssignment.test_withStatementTupleNamescCs| d¡dS)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 N)r)r r r r Útest_withStatementListNamesãsz0TestUnusedAssignment.test_withStatementListNamescCs| d¡dS)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 N)r)r r r r Ú#test_withStatementComplicatedTargetïsz8TestUnusedAssignment.test_withStatementComplicatedTargetcCs| dtj¡dS)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 N)rr r%)r r r r Ú%test_withStatementSingleNameUndefinedÿsz:TestUnusedAssignment.test_withStatementSingleNameUndefinedcCs| dtj¡dS)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 N)rr r%)r r r r Ú%test_withStatementTupleNamesUndefined sz:TestUnusedAssignment.test_withStatementTupleNamesUndefinedcCs| dtj¡dS)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 N)rr r)r r r r Ú%test_withStatementSingleNameRedefinedsz:TestUnusedAssignment.test_withStatementSingleNameRedefinedcCs| dtj¡dS)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 N)rr r)r r r r Ú%test_withStatementTupleNamesRedefined$sz:TestUnusedAssignment.test_withStatementTupleNamesRedefinedcCs| dtj¡dS)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 N)rr r%)r r r r Ú!test_withStatementUndefinedInside1sz6TestUnusedAssignment.test_withStatementUndefinedInsidecCs| d¡dS)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 N)r)r r r r Ú#test_withStatementNameDefinedInBody<sz8TestUnusedAssignment.test_withStatementNameDefinedInBodycCs | dtj¡| dtj¡dS)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 N)rr r%)r r r r Ú'test_withStatementUndefinedInExpressionHs z assert (False, 'x') assert (False, ) N)rr Z AssertTuple)r r r r Útest_assert_tuple·sz&TestUnusedAssignment.test_assert_tuplecCs| d¡dS)z,An assert of an empty tuple is always False.z assert () N)r)r r r r Útest_assert_tuple_empty¾sz,TestUnusedAssignment.test_assert_tuple_emptycCs| d¡dS)z,An assert of a static value is not an error.z. assert True assert 1 N)r)r r r r Útest_assert_staticÄsz'TestUnusedAssignment.test_assert_static)rrznew in Python 3.3cCs| dtj¡dS)z. Test C{yield from} statement z9 def bar(): yield from foo() N)rr r%)r r r r Útest_yieldFromUndefinedËsz,TestUnusedAssignment.test_yieldFromUndefined)réznew in Python 3.6cCs| d¡dS)z.Test PEP 498 f-strings are treated as a usage.z3 baz = 0 print(f'{4*baz}') N)r)r r r r Ú test_f_stringÕsz"TestUnusedAssignment.test_f_stringN)8rXrYrZÚ__doc__r\r]r^r_rr`rarbrrrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtrurvrwrxryrzr{r|r}r~rr€rr‚rƒr„r…r†r‡rˆr‰rŠr‹rr r r r r[ªsf                                  r[c@seZdZeedkdƒdd„ƒZeedkdƒdd„ƒZeedkdƒdd„ƒZeedkdƒd d „ƒZeedkdƒd d „ƒZ eedkdƒd d„ƒZ eedkdƒdd„ƒZ eedkdƒdd„ƒZ eedkdƒdd„ƒZ eedkdƒdd„ƒZeedkdƒdd„ƒZeedkdƒdd„ƒZdd„ZdS) ÚTestAsyncStatements)réznew in Python 3.5cCs| d¡dS)Nz8 async def bar(): return 42 )r)r r r r Ú test_asyncDefàsz!TestAsyncStatements.test_asyncDefcCs| d¡dS)NzS async def read_data(db): await db.fetch('SELECT ...') )r)r r r r Útest_asyncDefAwaitçsz&TestAsyncStatements.test_asyncDefAwaitcCs| dtj¡dS)Nz; async def bar(): return foo() )rr r%)r r r r Útest_asyncDefUndefinedîsz*TestAsyncStatements.test_asyncDefUndefinedcCs| d¡dS)Nz© async def read_data(db): output = [] async for row in db.cursor(): output.append(row) return output )r)r r r r Ú test_asyncForõsz!TestAsyncStatements.test_asyncForcCs| d¡dS)NzY async def coro(it): async for _ in it: pass )r)r r r r Útest_asyncForUnderscoreLoopVarÿsz2TestAsyncStatements.test_asyncForUnderscoreLoopVarcCs| d¡| d¡dS)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 r r r Útest_loopControlInAsyncForsz.TestAsyncStatements.test_loopControlInAsyncForcCs | dtj¡| dtj¡dS)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 )rr r4r9)r r r r Útest_loopControlInAsyncForElses z2TestAsyncStatements.test_loopControlInAsyncForElsecCs| dtj¡dS)Nzø async def read_data(db): output = [] async for row in db.cursor(): try: output.append(row) finally: continue return output )rr r7)r r r r Útest_continueInAsyncForFinally3s z2TestAsyncStatements.test_continueInAsyncForFinallycCs| d¡dS)Nz‹ async def commit(session, data): async with session.transaction(): await session.update(data) )r)r r r r Útest_asyncWith@sz"TestAsyncStatements.test_asyncWithcCs| d¡dS)Nzà async def commit(session, data): async with session.transaction() as trans: await trans.begin() ... await trans.end() )r)r r r r Útest_asyncWithItemHsz&TestAsyncStatements.test_asyncWithItemcCs| d¡dS)Nz9 def foo(a, b): return a @ b )r)r r r r Ú test_matmulRszTestAsyncStatements.test_matmul)rrŒznew in Python 3.6cCs| d¡dS)NzE hi = 'hi' mom = 'mom' f'{hi} {mom}' )r)r r r r Útest_formatstringYsz%TestAsyncStatements.test_formatstringcCs4| d¡| d¡| dtj¡| dtj¡dS)Nz; raise NotImplementedError("This is fine") z+ raise NotImplementedError z? raise NotImplemented("This isn't gonna work") z& raise NotImplemented )rr ZRaiseNotImplemented)r r r r Útest_raise_notimplementedas z-TestAsyncStatements.test_raise_notimplementedN)rXrYrZrrr‘r’r“r”r•r–r—r˜r™ršr›rœrr r r r rÞs   rc@s@eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dS)ÚTestIncompatiblePrintOperatorz@ Tests for warning about invalid use of print function. cCs| d¡dS)Nz print("Hello") )r)r r r r Útest_valid_printxsz.TestIncompatiblePrintOperator.test_valid_printcCs4| dtj¡jd}| |jd¡| |jd¡dS)Nzn from __future__ import print_function import sys print >>sys.stderr, "Hello" ré)rr ZInvalidPrintSyntaxrZ assertEqualÚlinenoÚcol)r Úexcr r r Ú,test_invalid_print_when_imported_from_future}szJTestIncompatiblePrintOperator.test_invalid_print_when_imported_from_futurecCs| d¡dS)zJ A valid assignment, tested for catching false positives. z` from __future__ import print_function log = print log("Hello") N)r)r r r r Útest_print_function_assignment‡szs*  (8