AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_scope.py

   1 import unittest
   2 from test.test_support import check_syntax_error, check_py3k_warnings, \
   3                               check_warnings, run_unittest
   4
   5
   6 class ScopeTests(unittest.TestCase):
   7
   8     def testSimpleNesting(self):
   9
  10         def make_adder(x):
  11             def adder(y):
  12                 return x + y
  13             return adder
  14
  15         inc = make_adder(1)
  16         plus10 = make_adder(10)
  17
  18         self.assertEqual(inc(1), 2)
  19         self.assertEqual(plus10(-2), 8)
  20
  21     def testExtraNesting(self):
  22
  23         def make_adder2(x):
  24             def extra(): # check freevars passing through non-use scopes
  25                 def adder(y):
  26                     return x + y
  27                 return adder
  28             return extra()
  29
  30         inc = make_adder2(1)
  31         plus10 = make_adder2(10)
  32
  33         self.assertEqual(inc(1), 2)
  34         self.assertEqual(plus10(-2), 8)
  35
  36     def testSimpleAndRebinding(self):
  37
  38         def make_adder3(x):
  39             def adder(y):
  40                 return x + y
  41             x = x + 1 # check tracking of assignment to x in defining scope
  42             return adder
  43
  44         inc = make_adder3(0)
  45         plus10 = make_adder3(9)
  46
  47         self.assertEqual(inc(1), 2)
  48         self.assertEqual(plus10(-2), 8)
  49
  50     def testNestingGlobalNoFree(self):
  51
  52         def make_adder4(): # XXX add exta level of indirection
  53             def nest():
  54                 def nest():
  55                     def adder(y):
  56                         return global_x + y # check that plain old globals work
  57                     return adder
  58                 return nest()
  59             return nest()
  60
  61         global_x = 1
  62         adder = make_adder4()
  63         self.assertEqual(adder(1), 2)
  64
  65         global_x = 10
  66         self.assertEqual(adder(-2), 8)
  67
  68     def testNestingThroughClass(self):
  69
  70         def make_adder5(x):
  71             class Adder:
  72                 def __call__(self, y):
  73                     return x + y
  74             return Adder()
  75
  76         inc = make_adder5(1)
  77         plus10 = make_adder5(10)
  78
  79         self.assertEqual(inc(1), 2)
  80         self.assertEqual(plus10(-2), 8)
  81
  82     def testNestingPlusFreeRefToGlobal(self):
  83
  84         def make_adder6(x):
  85             global global_nest_x
  86             def adder(y):
  87                 return global_nest_x + y
  88             global_nest_x = x
  89             return adder
  90
  91         inc = make_adder6(1)
  92         plus10 = make_adder6(10)
  93
  94         self.assertEqual(inc(1), 11) # there's only one global
  95         self.assertEqual(plus10(-2), 8)
  96
  97     def testNearestEnclosingScope(self):
  98
  99         def f(x):
 100             def g(y):
 101                 x = 42 # check that this masks binding in f()
 102                 def h(z):
 103                     return x + z
 104                 return h
 105             return g(2)
 106
 107         test_func = f(10)
 108         self.assertEqual(test_func(5), 47)
 109
 110     def testMixedFreevarsAndCellvars(self):
 111
 112         def identity(x):
 113             return x
 114
 115         def f(x, y, z):
 116             def g(a, b, c):
 117                 a = a + x # 3
 118                 def h():
 119                     # z * (4 + 9)
 120                     # 3 * 13
 121                     return identity(z * (b + y))
 122                 y = c + z # 9
 123                 return h
 124             return g
 125
 126         g = f(1, 2, 3)
 127         h = g(2, 4, 6)
 128         self.assertEqual(h(), 39)
 129
 130     def testFreeVarInMethod(self):
 131
 132         def test():
 133             method_and_var = "var"
 134             class Test:
 135                 def method_and_var(self):
 136                     return "method"
 137                 def test(self):
 138                     return method_and_var
 139                 def actual_global(self):
 140                     return str("global")
 141                 def str(self):
 142                     return str(self)
 143             return Test()
 144
 145         t = test()
 146         self.assertEqual(t.test(), "var")
 147         self.assertEqual(t.method_and_var(), "method")
 148         self.assertEqual(t.actual_global(), "global")
 149
 150         method_and_var = "var"
 151         class Test:
 152             # this class is not nested, so the rules are different
 153             def method_and_var(self):
 154                 return "method"
 155             def test(self):
 156                 return method_and_var
 157             def actual_global(self):
 158                 return str("global")
 159             def str(self):
 160                 return str(self)
 161
 162         t = Test()
 163         self.assertEqual(t.test(), "var")
 164         self.assertEqual(t.method_and_var(), "method")
 165         self.assertEqual(t.actual_global(), "global")
 166
 167     def testRecursion(self):
 168
 169         def f(x):
 170             def fact(n):
 171                 if n == 0:
 172                     return 1
 173                 else:
 174                     return n * fact(n - 1)
 175             if x >= 0:
 176                 return fact(x)
 177             else:
 178                 raise ValueError, "x must be >= 0"
 179
 180         self.assertEqual(f(6), 720)
 181
 182
 183     def testUnoptimizedNamespaces(self):
 184
 185         check_syntax_error(self, """\
 186 def unoptimized_clash1(strip):
 187     def f(s):
 188         from string import *
 189         return strip(s) # ambiguity: free or local
 190     return f
 191 """)
 192
 193         check_syntax_error(self, """\
 194 def unoptimized_clash2():
 195     from string import *
 196     def f(s):
 197         return strip(s) # ambiguity: global or local
 198     return f
 199 """)
 200
 201         check_syntax_error(self, """\
 202 def unoptimized_clash2():
 203     from string import *
 204     def g():
 205         def f(s):
 206             return strip(s) # ambiguity: global or local
 207         return f
 208 """)
 209
 210         # XXX could allow this for exec with const argument, but what's the point
 211         check_syntax_error(self, """\
 212 def error(y):
 213     exec "a = 1"
 214     def f(x):
 215         return x + y
 216     return f
 217 """)
 218
 219         check_syntax_error(self, """\
 220 def f(x):
 221     def g():
 222         return x
 223     del x # can't del name
 224 """)
 225
 226         check_syntax_error(self, """\
 227 def f():
 228     def g():
 229         from string import *
 230         return strip # global or local?
 231 """)
 232
 233         # and verify a few cases that should work
 234
 235         exec """
 236 def noproblem1():
 237     from string import *
 238     f = lambda x:x
 239
 240 def noproblem2():
 241     from string import *
 242     def f(x):
 243         return x + 1
 244
 245 def noproblem3():
 246     from string import *
 247     def f(x):
 248         global y
 249         y = x
 250 """
 251
 252     def testLambdas(self):
 253
 254         f1 = lambda x: lambda y: x + y
 255         inc = f1(1)
 256         plus10 = f1(10)
 257         self.assertEqual(inc(1), 2)
 258         self.assertEqual(plus10(5), 15)
 259
 260         f2 = lambda x: (lambda : lambda y: x + y)()
 261         inc = f2(1)
 262         plus10 = f2(10)
 263         self.assertEqual(inc(1), 2)
 264         self.assertEqual(plus10(5), 15)
 265
 266         f3 = lambda x: lambda y: global_x + y
 267         global_x = 1
 268         inc = f3(None)
 269         self.assertEqual(inc(2), 3)
 270
 271         f8 = lambda x, y, z: lambda a, b, c: lambda : z * (b + y)
 272         g = f8(1, 2, 3)
 273         h = g(2, 4, 6)
 274         self.assertEqual(h(), 18)
 275
 276     def testUnboundLocal(self):
 277
 278         def errorInOuter():
 279             print y
 280             def inner():
 281                 return y
 282             y = 1
 283
 284         def errorInInner():
 285             def inner():
 286                 return y
 287             inner()
 288             y = 1
 289
 290         self.assertRaises(UnboundLocalError, errorInOuter)
 291         self.assertRaises(NameError, errorInInner)
 292
 293         # test for bug #1501934: incorrect LOAD/STORE_GLOBAL generation
 294         exec """
 295 global_x = 1
 296 def f():
 297     global_x += 1
 298 try:
 299     f()
 300 except UnboundLocalError:
 301     pass
 302 else:
 303     fail('scope of global_x not correctly determined')
 304 """ in {'fail': self.fail}
 305
 306     def testComplexDefinitions(self):
 307
 308         def makeReturner(*lst):
 309             def returner():
 310                 return lst
 311             return returner
 312
 313         self.assertEqual(makeReturner(1,2,3)(), (1,2,3))
 314
 315         def makeReturner2(**kwargs):
 316             def returner():
 317                 return kwargs
 318             return returner
 319
 320         self.assertEqual(makeReturner2(a=11)()['a'], 11)
 321
 322         with check_py3k_warnings(("tuple parameter unpacking has been removed",
 323                                   SyntaxWarning)):
 324             exec """\
 325 def makeAddPair((a, b)):
 326     def addPair((c, d)):
 327         return (a + c, b + d)
 328     return addPair
 329 """ in locals()
 330         self.assertEqual(makeAddPair((1, 2))((100, 200)), (101,202))
 331
 332     def testScopeOfGlobalStmt(self):
 333 # Examples posted by Samuele Pedroni to python-dev on 3/1/2001
 334
 335         exec """\
 336 # I
 337 x = 7
 338 def f():
 339     x = 1
 340     def g():
 341         global x
 342         def i():
 343             def h():
 344                 return x
 345             return h()
 346         return i()
 347     return g()
 348 self.assertEqual(f(), 7)
 349 self.assertEqual(x, 7)
 350
 351 # II
 352 x = 7
 353 def f():
 354     x = 1
 355     def g():
 356         x = 2
 357         def i():
 358             def h():
 359                 return x
 360             return h()
 361         return i()
 362     return g()
 363 self.assertEqual(f(), 2)
 364 self.assertEqual(x, 7)
 365
 366 # III
 367 x = 7
 368 def f():
 369     x = 1
 370     def g():
 371         global x
 372         x = 2
 373         def i():
 374             def h():
 375                 return x
 376             return h()
 377         return i()
 378     return g()
 379 self.assertEqual(f(), 2)
 380 self.assertEqual(x, 2)
 381
 382 # IV
 383 x = 7
 384 def f():
 385     x = 3
 386     def g():
 387         global x
 388         x = 2
 389         def i():
 390             def h():
 391                 return x
 392             return h()
 393         return i()
 394     return g()
 395 self.assertEqual(f(), 2)
 396 self.assertEqual(x, 2)
 397
 398 # XXX what about global statements in class blocks?
 399 # do they affect methods?
 400
 401 x = 12
 402 class Global:
 403     global x
 404     x = 13
 405     def set(self, val):
 406         x = val
 407     def get(self):
 408         return x
 409
 410 g = Global()
 411 self.assertEqual(g.get(), 13)
 412 g.set(15)
 413 self.assertEqual(g.get(), 13)
 414 """
 415
 416     def testLeaks(self):
 417
 418         class Foo:
 419             count = 0
 420
 421             def __init__(self):
 422                 Foo.count += 1
 423
 424             def __del__(self):
 425                 Foo.count -= 1
 426
 427         def f1():
 428             x = Foo()
 429             def f2():
 430                 return x
 431             f2()
 432
 433         for i in range(100):
 434             f1()
 435
 436         self.assertEqual(Foo.count, 0)
 437
 438     def testClassAndGlobal(self):
 439
 440         exec """\
 441 def test(x):
 442     class Foo:
 443         global x
 444         def __call__(self, y):
 445             return x + y
 446     return Foo()
 447
 448 x = 0
 449 self.assertEqual(test(6)(2), 8)
 450 x = -1
 451 self.assertEqual(test(3)(2), 5)
 452
 453 looked_up_by_load_name = False
 454 class X:
 455     # Implicit globals inside classes are be looked up by LOAD_NAME, not
 456     # LOAD_GLOBAL.
 457     locals()['looked_up_by_load_name'] = True
 458     passed = looked_up_by_load_name
 459
 460 self.assertTrue(X.passed)
 461 """
 462
 463     def testLocalsFunction(self):
 464
 465         def f(x):
 466             def g(y):
 467                 def h(z):
 468                     return y + z
 469                 w = x + y
 470                 y += 3
 471                 return locals()
 472             return g
 473
 474         d = f(2)(4)
 475         self.assertIn('h', d)
 476         del d['h']
 477         self.assertEqual(d, {'x': 2, 'y': 7, 'w': 6})
 478
 479     def testLocalsClass(self):
 480         # This test verifies that calling locals() does not pollute
 481         # the local namespace of the class with free variables.  Old
 482         # versions of Python had a bug, where a free variable being
 483         # passed through a class namespace would be inserted into
 484         # locals() by locals() or exec or a trace function.
 485         #
 486         # The real bug lies in frame code that copies variables
 487         # between fast locals and the locals dict, e.g. when executing
 488         # a trace function.
 489
 490         def f(x):
 491             class C:
 492                 x = 12
 493                 def m(self):
 494                     return x
 495                 locals()
 496             return C
 497
 498         self.assertEqual(f(1).x, 12)
 499
 500         def f(x):
 501             class C:
 502                 y = x
 503                 def m(self):
 504                     return x
 505                 z = list(locals())
 506             return C
 507
 508         varnames = f(1).z
 509         self.assertNotIn("x", varnames)
 510         self.assertIn("y", varnames)
 511
 512     def testLocalsClass_WithTrace(self):
 513         # Issue23728: after the trace function returns, the locals()
 514         # dictionary is used to update all variables, this used to
 515         # include free variables. But in class statements, free
 516         # variables are not inserted...
 517         import sys
 518         sys.settrace(lambda a,b,c:None)
 519         try:
 520             x = 12
 521
 522             class C:
 523                 def f(self):
 524                     return x
 525
 526             self.assertEqual(x, 12) # Used to raise UnboundLocalError
 527         finally:
 528             sys.settrace(None)
 529
 530     def testBoundAndFree(self):
 531         # var is bound and free in class
 532
 533         def f(x):
 534             class C:
 535                 def m(self):
 536                     return x
 537                 a = x
 538             return C
 539
 540         inst = f(3)()
 541         self.assertEqual(inst.a, inst.m())
 542
 543     def testInteractionWithTraceFunc(self):
 544
 545         import sys
 546         def tracer(a,b,c):
 547             return tracer
 548
 549         def adaptgetter(name, klass, getter):
 550             kind, des = getter
 551             if kind == 1:       # AV happens when stepping from this line to next
 552                 if des == "":
 553                     des = "_%s__%s" % (klass.__name__, name)
 554                 return lambda obj: getattr(obj, des)
 555
 556         class TestClass:
 557             pass
 558
 559         sys.settrace(tracer)
 560         adaptgetter("foo", TestClass, (1, ""))
 561         sys.settrace(None)
 562
 563         self.assertRaises(TypeError, sys.settrace)
 564
 565     def testEvalExecFreeVars(self):
 566
 567         def f(x):
 568             return lambda: x + 1
 569
 570         g = f(3)
 571         self.assertRaises(TypeError, eval, g.func_code)
 572
 573         try:
 574             exec g.func_code in {}
 575         except TypeError:
 576             pass
 577         else:
 578             self.fail("exec should have failed, because code contained free vars")
 579
 580     def testListCompLocalVars(self):
 581
 582         try:
 583             print bad
 584         except NameError:
 585             pass
 586         else:
 587             print "bad should not be defined"
 588
 589         def x():
 590             [bad for s in 'a b' for bad in s.split()]
 591
 592         x()
 593         try:
 594             print bad
 595         except NameError:
 596             pass
 597
 598     def testEvalFreeVars(self):
 599
 600         def f(x):
 601             def g():
 602                 x
 603                 eval("x + 1")
 604             return g
 605
 606         f(4)()
 607
 608     def testFreeingCell(self):
 609         # Test what happens when a finalizer accesses
 610         # the cell where the object was stored.
 611         class Special:
 612             def __del__(self):
 613                 nestedcell_get()
 614
 615         def f():
 616             global nestedcell_get
 617             def nestedcell_get():
 618                 return c
 619
 620             c = (Special(),)
 621             c = 2
 622
 623         f() # used to crash the interpreter...
 624
 625     def testGlobalInParallelNestedFunctions(self):
 626         # A symbol table bug leaked the global statement from one
 627         # function to other nested functions in the same block.
 628         # This test verifies that a global statement in the first
 629         # function does not affect the second function.
 630         CODE = """def f():
 631     y = 1
 632     def g():
 633         global y
 634         return y
 635     def h():
 636         return y + 1
 637     return g, h
 638
 639 y = 9
 640 g, h = f()
 641 result9 = g()
 642 result2 = h()
 643 """
 644         local_ns = {}
 645         global_ns = {}
 646         exec CODE in local_ns, global_ns
 647         self.assertEqual(2, global_ns["result2"])
 648         self.assertEqual(9, global_ns["result9"])
 649
 650     def testTopIsNotSignificant(self):
 651         # See #9997.
 652         def top(a):
 653             pass
 654         def b():
 655             global a
 656
 657
 658 def test_main():
 659     with check_warnings(("import \* only allowed at module level",
 660                          SyntaxWarning)):
 661         run_unittest(ScopeTests)
 662
 663 if __name__ == '__main__':
 664     test_main()