EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / test / test_scope.py

import unittest\r
from test.test_support import check_syntax_error, check_py3k_warnings, \\r
                              check_warnings, run_unittest\r
\r
\r
class ScopeTests(unittest.TestCase):\r
\r
    def testSimpleNesting(self):\r
\r
        def make_adder(x):\r
            def adder(y):\r
                return x + y\r
            return adder\r
\r
        inc = make_adder(1)\r
        plus10 = make_adder(10)\r
\r
        self.assertEqual(inc(1), 2)\r
        self.assertEqual(plus10(-2), 8)\r
\r
    def testExtraNesting(self):\r
\r
        def make_adder2(x):\r
            def extra(): # check freevars passing through non-use scopes\r
                def adder(y):\r
                    return x + y\r
                return adder\r
            return extra()\r
\r
        inc = make_adder2(1)\r
        plus10 = make_adder2(10)\r
\r
        self.assertEqual(inc(1), 2)\r
        self.assertEqual(plus10(-2), 8)\r
\r
    def testSimpleAndRebinding(self):\r
\r
        def make_adder3(x):\r
            def adder(y):\r
                return x + y\r
            x = x + 1 # check tracking of assignment to x in defining scope\r
            return adder\r
\r
        inc = make_adder3(0)\r
        plus10 = make_adder3(9)\r
\r
        self.assertEqual(inc(1), 2)\r
        self.assertEqual(plus10(-2), 8)\r
\r
    def testNestingGlobalNoFree(self):\r
\r
        def make_adder4(): # XXX add exta level of indirection\r
            def nest():\r
                def nest():\r
                    def adder(y):\r
                        return global_x + y # check that plain old globals work\r
                    return adder\r
                return nest()\r
            return nest()\r
\r
        global_x = 1\r
        adder = make_adder4()\r
        self.assertEqual(adder(1), 2)\r
\r
        global_x = 10\r
        self.assertEqual(adder(-2), 8)\r
\r
    def testNestingThroughClass(self):\r
\r
        def make_adder5(x):\r
            class Adder:\r
                def __call__(self, y):\r
                    return x + y\r
            return Adder()\r
\r
        inc = make_adder5(1)\r
        plus10 = make_adder5(10)\r
\r
        self.assertEqual(inc(1), 2)\r
        self.assertEqual(plus10(-2), 8)\r
\r
    def testNestingPlusFreeRefToGlobal(self):\r
\r
        def make_adder6(x):\r
            global global_nest_x\r
            def adder(y):\r
                return global_nest_x + y\r
            global_nest_x = x\r
            return adder\r
\r
        inc = make_adder6(1)\r
        plus10 = make_adder6(10)\r
\r
        self.assertEqual(inc(1), 11) # there's only one global\r
        self.assertEqual(plus10(-2), 8)\r
\r
    def testNearestEnclosingScope(self):\r
\r
        def f(x):\r
            def g(y):\r
                x = 42 # check that this masks binding in f()\r
                def h(z):\r
                    return x + z\r
                return h\r
            return g(2)\r
\r
        test_func = f(10)\r
        self.assertEqual(test_func(5), 47)\r
\r
    def testMixedFreevarsAndCellvars(self):\r
\r
        def identity(x):\r
            return x\r
\r
        def f(x, y, z):\r
            def g(a, b, c):\r
                a = a + x # 3\r
                def h():\r
                    # z * (4 + 9)\r
                    # 3 * 13\r
                    return identity(z * (b + y))\r
                y = c + z # 9\r
                return h\r
            return g\r
\r
        g = f(1, 2, 3)\r
        h = g(2, 4, 6)\r
        self.assertEqual(h(), 39)\r
\r
    def testFreeVarInMethod(self):\r
\r
        def test():\r
            method_and_var = "var"\r
            class Test:\r
                def method_and_var(self):\r
                    return "method"\r
                def test(self):\r
                    return method_and_var\r
                def actual_global(self):\r
                    return str("global")\r
                def str(self):\r
                    return str(self)\r
            return Test()\r
\r
        t = test()\r
        self.assertEqual(t.test(), "var")\r
        self.assertEqual(t.method_and_var(), "method")\r
        self.assertEqual(t.actual_global(), "global")\r
\r
        method_and_var = "var"\r
        class Test:\r
            # this class is not nested, so the rules are different\r
            def method_and_var(self):\r
                return "method"\r
            def test(self):\r
                return method_and_var\r
            def actual_global(self):\r
                return str("global")\r
            def str(self):\r
                return str(self)\r
\r
        t = Test()\r
        self.assertEqual(t.test(), "var")\r
        self.assertEqual(t.method_and_var(), "method")\r
        self.assertEqual(t.actual_global(), "global")\r
\r
    def testRecursion(self):\r
\r
        def f(x):\r
            def fact(n):\r
                if n == 0:\r
                    return 1\r
                else:\r
                    return n * fact(n - 1)\r
            if x >= 0:\r
                return fact(x)\r
            else:\r
                raise ValueError, "x must be >= 0"\r
\r
        self.assertEqual(f(6), 720)\r
\r
\r
    def testUnoptimizedNamespaces(self):\r
\r
        check_syntax_error(self, """\\r
def unoptimized_clash1(strip):\r
    def f(s):\r
        from string import *\r
        return strip(s) # ambiguity: free or local\r
    return f\r
""")\r
\r
        check_syntax_error(self, """\\r
def unoptimized_clash2():\r
    from string import *\r
    def f(s):\r
        return strip(s) # ambiguity: global or local\r
    return f\r
""")\r
\r
        check_syntax_error(self, """\\r
def unoptimized_clash2():\r
    from string import *\r
    def g():\r
        def f(s):\r
            return strip(s) # ambiguity: global or local\r
        return f\r
""")\r
\r
        # XXX could allow this for exec with const argument, but what's the point\r
        check_syntax_error(self, """\\r
def error(y):\r
    exec "a = 1"\r
    def f(x):\r
        return x + y\r
    return f\r
""")\r
\r
        check_syntax_error(self, """\\r
def f(x):\r
    def g():\r
        return x\r
    del x # can't del name\r
""")\r
\r
        check_syntax_error(self, """\\r
def f():\r
    def g():\r
        from string import *\r
        return strip # global or local?\r
""")\r
\r
        # and verify a few cases that should work\r
\r
        exec """\r
def noproblem1():\r
    from string import *\r
    f = lambda x:x\r
\r
def noproblem2():\r
    from string import *\r
    def f(x):\r
        return x + 1\r
\r
def noproblem3():\r
    from string import *\r
    def f(x):\r
        global y\r
        y = x\r
"""\r
\r
    def testLambdas(self):\r
\r
        f1 = lambda x: lambda y: x + y\r
        inc = f1(1)\r
        plus10 = f1(10)\r
        self.assertEqual(inc(1), 2)\r
        self.assertEqual(plus10(5), 15)\r
\r
        f2 = lambda x: (lambda : lambda y: x + y)()\r
        inc = f2(1)\r
        plus10 = f2(10)\r
        self.assertEqual(inc(1), 2)\r
        self.assertEqual(plus10(5), 15)\r
\r
        f3 = lambda x: lambda y: global_x + y\r
        global_x = 1\r
        inc = f3(None)\r
        self.assertEqual(inc(2), 3)\r
\r
        f8 = lambda x, y, z: lambda a, b, c: lambda : z * (b + y)\r
        g = f8(1, 2, 3)\r
        h = g(2, 4, 6)\r
        self.assertEqual(h(), 18)\r
\r
    def testUnboundLocal(self):\r
\r
        def errorInOuter():\r
            print y\r
            def inner():\r
                return y\r
            y = 1\r
\r
        def errorInInner():\r
            def inner():\r
                return y\r
            inner()\r
            y = 1\r
\r
        self.assertRaises(UnboundLocalError, errorInOuter)\r
        self.assertRaises(NameError, errorInInner)\r
\r
        # test for bug #1501934: incorrect LOAD/STORE_GLOBAL generation\r
        exec """\r
global_x = 1\r
def f():\r
    global_x += 1\r
try:\r
    f()\r
except UnboundLocalError:\r
    pass\r
else:\r
    fail('scope of global_x not correctly determined')\r
""" in {'fail': self.fail}\r
\r
    def testComplexDefinitions(self):\r
\r
        def makeReturner(*lst):\r
            def returner():\r
                return lst\r
            return returner\r
\r
        self.assertEqual(makeReturner(1,2,3)(), (1,2,3))\r
\r
        def makeReturner2(**kwargs):\r
            def returner():\r
                return kwargs\r
            return returner\r
\r
        self.assertEqual(makeReturner2(a=11)()['a'], 11)\r
\r
        with check_py3k_warnings(("tuple parameter unpacking has been removed",\r
                                  SyntaxWarning)):\r
            exec """\\r
def makeAddPair((a, b)):\r
    def addPair((c, d)):\r
        return (a + c, b + d)\r
    return addPair\r
""" in locals()\r
        self.assertEqual(makeAddPair((1, 2))((100, 200)), (101,202))\r
\r
    def testScopeOfGlobalStmt(self):\r
# Examples posted by Samuele Pedroni to python-dev on 3/1/2001\r
\r
        exec """\\r
# I\r
x = 7\r
def f():\r
    x = 1\r
    def g():\r
        global x\r
        def i():\r
            def h():\r
                return x\r
            return h()\r
        return i()\r
    return g()\r
self.assertEqual(f(), 7)\r
self.assertEqual(x, 7)\r
\r
# II\r
x = 7\r
def f():\r
    x = 1\r
    def g():\r
        x = 2\r
        def i():\r
            def h():\r
                return x\r
            return h()\r
        return i()\r
    return g()\r
self.assertEqual(f(), 2)\r
self.assertEqual(x, 7)\r
\r
# III\r
x = 7\r
def f():\r
    x = 1\r
    def g():\r
        global x\r
        x = 2\r
        def i():\r
            def h():\r
                return x\r
            return h()\r
        return i()\r
    return g()\r
self.assertEqual(f(), 2)\r
self.assertEqual(x, 2)\r
\r
# IV\r
x = 7\r
def f():\r
    x = 3\r
    def g():\r
        global x\r
        x = 2\r
        def i():\r
            def h():\r
                return x\r
            return h()\r
        return i()\r
    return g()\r
self.assertEqual(f(), 2)\r
self.assertEqual(x, 2)\r
\r
# XXX what about global statements in class blocks?\r
# do they affect methods?\r
\r
x = 12\r
class Global:\r
    global x\r
    x = 13\r
    def set(self, val):\r
        x = val\r
    def get(self):\r
        return x\r
\r
g = Global()\r
self.assertEqual(g.get(), 13)\r
g.set(15)\r
self.assertEqual(g.get(), 13)\r
"""\r
\r
    def testLeaks(self):\r
\r
        class Foo:\r
            count = 0\r
\r
            def __init__(self):\r
                Foo.count += 1\r
\r
            def __del__(self):\r
                Foo.count -= 1\r
\r
        def f1():\r
            x = Foo()\r
            def f2():\r
                return x\r
            f2()\r
\r
        for i in range(100):\r
            f1()\r
\r
        self.assertEqual(Foo.count, 0)\r
\r
    def testClassAndGlobal(self):\r
\r
        exec """\\r
def test(x):\r
    class Foo:\r
        global x\r
        def __call__(self, y):\r
            return x + y\r
    return Foo()\r
\r
x = 0\r
self.assertEqual(test(6)(2), 8)\r
x = -1\r
self.assertEqual(test(3)(2), 5)\r
\r
looked_up_by_load_name = False\r
class X:\r
    # Implicit globals inside classes are be looked up by LOAD_NAME, not\r
    # LOAD_GLOBAL.\r
    locals()['looked_up_by_load_name'] = True\r
    passed = looked_up_by_load_name\r
\r
self.assertTrue(X.passed)\r
"""\r
\r
    def testLocalsFunction(self):\r
\r
        def f(x):\r
            def g(y):\r
                def h(z):\r
                    return y + z\r
                w = x + y\r
                y += 3\r
                return locals()\r
            return g\r
\r
        d = f(2)(4)\r
        self.assertIn('h', d)\r
        del d['h']\r
        self.assertEqual(d, {'x': 2, 'y': 7, 'w': 6})\r
\r
    def testLocalsClass(self):\r
        # This test verifies that calling locals() does not pollute\r
        # the local namespace of the class with free variables.  Old\r
        # versions of Python had a bug, where a free variable being\r
        # passed through a class namespace would be inserted into\r
        # locals() by locals() or exec or a trace function.\r
        #\r
        # The real bug lies in frame code that copies variables\r
        # between fast locals and the locals dict, e.g. when executing\r
        # a trace function.\r
\r
        def f(x):\r
            class C:\r
                x = 12\r
                def m(self):\r
                    return x\r
                locals()\r
            return C\r
\r
        self.assertEqual(f(1).x, 12)\r
\r
        def f(x):\r
            class C:\r
                y = x\r
                def m(self):\r
                    return x\r
                z = list(locals())\r
            return C\r
\r
        varnames = f(1).z\r
        self.assertNotIn("x", varnames)\r
        self.assertIn("y", varnames)\r
\r
    def testLocalsClass_WithTrace(self):\r
        # Issue23728: after the trace function returns, the locals()\r
        # dictionary is used to update all variables, this used to\r
        # include free variables. But in class statements, free\r
        # variables are not inserted...\r
        import sys\r
        sys.settrace(lambda a,b,c:None)\r
        try:\r
            x = 12\r
\r
            class C:\r
                def f(self):\r
                    return x\r
\r
            self.assertEqual(x, 12) # Used to raise UnboundLocalError\r
        finally:\r
            sys.settrace(None)\r
\r
    def testBoundAndFree(self):\r
        # var is bound and free in class\r
\r
        def f(x):\r
            class C:\r
                def m(self):\r
                    return x\r
                a = x\r
            return C\r
\r
        inst = f(3)()\r
        self.assertEqual(inst.a, inst.m())\r
\r
    def testInteractionWithTraceFunc(self):\r
\r
        import sys\r
        def tracer(a,b,c):\r
            return tracer\r
\r
        def adaptgetter(name, klass, getter):\r
            kind, des = getter\r
            if kind == 1:       # AV happens when stepping from this line to next\r
                if des == "":\r
                    des = "_%s__%s" % (klass.__name__, name)\r
                return lambda obj: getattr(obj, des)\r
\r
        class TestClass:\r
            pass\r
\r
        sys.settrace(tracer)\r
        adaptgetter("foo", TestClass, (1, ""))\r
        sys.settrace(None)\r
\r
        self.assertRaises(TypeError, sys.settrace)\r
\r
    def testEvalExecFreeVars(self):\r
\r
        def f(x):\r
            return lambda: x + 1\r
\r
        g = f(3)\r
        self.assertRaises(TypeError, eval, g.func_code)\r
\r
        try:\r
            exec g.func_code in {}\r
        except TypeError:\r
            pass\r
        else:\r
            self.fail("exec should have failed, because code contained free vars")\r
\r
    def testListCompLocalVars(self):\r
\r
        try:\r
            print bad\r
        except NameError:\r
            pass\r
        else:\r
            print "bad should not be defined"\r
\r
        def x():\r
            [bad for s in 'a b' for bad in s.split()]\r
\r
        x()\r
        try:\r
            print bad\r
        except NameError:\r
            pass\r
\r
    def testEvalFreeVars(self):\r
\r
        def f(x):\r
            def g():\r
                x\r
                eval("x + 1")\r
            return g\r
\r
        f(4)()\r
\r
    def testFreeingCell(self):\r
        # Test what happens when a finalizer accesses\r
        # the cell where the object was stored.\r
        class Special:\r
            def __del__(self):\r
                nestedcell_get()\r
\r
        def f():\r
            global nestedcell_get\r
            def nestedcell_get():\r
                return c\r
\r
            c = (Special(),)\r
            c = 2\r
\r
        f() # used to crash the interpreter...\r
\r
    def testGlobalInParallelNestedFunctions(self):\r
        # A symbol table bug leaked the global statement from one\r
        # function to other nested functions in the same block.\r
        # This test verifies that a global statement in the first\r
        # function does not affect the second function.\r
        CODE = """def f():\r
    y = 1\r
    def g():\r
        global y\r
        return y\r
    def h():\r
        return y + 1\r
    return g, h\r
\r
y = 9\r
g, h = f()\r
result9 = g()\r
result2 = h()\r
"""\r
        local_ns = {}\r
        global_ns = {}\r
        exec CODE in local_ns, global_ns\r
        self.assertEqual(2, global_ns["result2"])\r
        self.assertEqual(9, global_ns["result9"])\r
\r
    def testTopIsNotSignificant(self):\r
        # See #9997.\r
        def top(a):\r
            pass\r
        def b():\r
            global a\r
\r
\r
def test_main():\r
    with check_warnings(("import \* only allowed at module level",\r
                         SyntaxWarning)):\r
        run_unittest(ScopeTests)\r
\r
if __name__ == '__main__':\r
    test_main()\r