def test_member_acces_after_possible_assignment(self):
        tree = ast.parse(
            textwrap.dedent(
                """
                def f():
                    if 0:
                       x = 2
                    x.y
                """
                )
            )
        expectedResult = set(['x'])
        self.assertEqual(
            expectedResult,
            PyAstUninstantiatedVariablesAnalysis.
                collectPossiblyUninitializedLocalVariables(tree)
            )

        self.assertEqual(
            set(),
            PyAstFreeVariableAnalyses.getFreeVariables(tree)
            )

        self.assertEqual(
            set(),
            PyAstFreeVariableAnalyses.getFreeVariableMemberAccessChains(tree)
            )        

 def test_freeVariables_globalStmt_2(self):
     tree = ast.parse(
         textwrap.dedent(
             """
             def f():
                 global x
                 return x
             """
             )
         )
     with self.assertRaises(Exceptions.PythonToForaConversionError):
         PyAstFreeVariableAnalyses.getFreeVariables(tree)

def collectPossiblyUninitializedLocalVariablesInScope(pyAstNode):
    boundVariables = PyAstFreeVariableAnalyses.collectBoundVariablesInScope(pyAstNode)
    visitor = _PossiblyUninitializedLocalVariablesInScopeVisitor(
        pyAstNode,
        boundVariables)
    possiblyUninitializedVariables = visitor.getPossiblyUninitializedLocalVariablesInScope()
    return possiblyUninitializedVariables

    def test_memberAccessChain_2(self):
        tree = ast.parse("(1).y.z.w")

        self.assertIsNone(
            PyAstFreeVariableAnalyses._memberAccessChainOrNone(
                tree.body[0].value
                )
            )

    def test_CollectBoundVariablesInScope_classDef(self):
        tree = ast.parse(
            textwrap.dedent(
                """
                v0 = z
                class c(x):
                    v1
                    v2 = 2
                    v3 += 3
                    (v4, v5), v6 = w
                v7 = zz
                """
            )
        )

        self.assertEqual(set(["v0", "v7"]), PyAstFreeVariableAnalyses.collectBoundVariablesInScope(tree))
        self.assertEqual(set(["c"]), PyAstFreeVariableAnalyses.collectBoundNamesInScope(tree))

    def test_memberAccessChain_1(self):
        tree = ast.parse("x.y.z.w")

        self.assertEqual(
            ('x', 'y', 'z', 'w'),
            PyAstFreeVariableAnalyses._memberAccessChainOrNone(
                tree.body[0].value
                )
            )

    def test_freeVariables_DictComp_2(self):
        tree = ast.parse(
            textwrap.dedent(
                """
                d = { x1: y1 for x2, y2 in o.f() }
                """
                )
            )

        self.assertEqual(
            set(['o', 'x1', 'y1']),
            PyAstFreeVariableAnalyses.getFreeVariables(tree)
            )

    def test_freeVariables_DictComp_1(self):
        tree = ast.parse(
            textwrap.dedent(
                """
                d = { x: y for x, y in o.f() }
                """
                )
            )

        self.assertEqual(
            set(['o']),
            PyAstFreeVariableAnalyses.getFreeVariables(tree)
            )

    def test_freeVariables_SetComp_1(self):
        tree = ast.parse(
            textwrap.dedent(
                """
                {v for x in q}
                """
                )
            )

        self.assertEqual(
            set(['v', 'q']),
            PyAstFreeVariableAnalyses.getFreeVariables(tree)
            )

 def test_freeVariables_ListComp_4(self):
     tree = ast.parse(
         textwrap.dedent(
             """
             [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
             """
             )
         )
     
     self.assertEqual(
         set(),
         PyAstFreeVariableAnalyses.getFreeVariables(tree)
         )

    def test_freeVariables_ListComp_2(self):
        tree = ast.parse(
            textwrap.dedent(
                """
                [val for val in x if val == free]
                """
                )
            )

        self.assertEqual(
            set(['free', 'x']),
            PyAstFreeVariableAnalyses.getFreeVariables(tree)
            )

    def test_freeVariables_Lambda_1(self):
        tree = ast.parse(
            textwrap.dedent(
                """
                lambda x, y = z, *args, **kwargs: (x, y, args, kwargs, free)
                """
                )
            )

        self.assertEqual(
            set(['z', 'free']),
            PyAstFreeVariableAnalyses.getFreeVariables(tree)
            )

    def test_freeVariables_functionDef_2(self):
        tree = ast.parse(
            textwrap.dedent(
                """def outer():
                    def f(x):
                        return len(f)"""
                )
            )

        self.assertEqual(
            set(['len']),
            PyAstFreeVariableAnalyses.getFreeVariables(tree)
            )

    def test_freeVariables_Assign(self):
        tree = ast.parse(
            textwrap.dedent(
                """
                (x, y), z = w
                """
                )
            )

        self.assertEqual(
            set(['w']),
            PyAstFreeVariableAnalyses.getFreeVariables(tree)
            )

    def test_freeVariables_function_context(self):
        tree = ast.parse(
            textwrap.dedent(
                """
                def fib(x):
                    if x < 2:
                        return 1
                    else:
                        return fib(x-1) + fib(x-2)
                """
                )
            )

        self.assertEqual(
            set([]),
            PyAstFreeVariableAnalyses.getFreeVariables(tree.body[0], isClassContext = False)
            )

        self.assertEqual(
            set(['fib']),
            PyAstFreeVariableAnalyses.getFreeVariables(tree.body[0], isClassContext = True)
            )

    def test_freeVariables_classDef_1(self):
        tree = ast.parse(
            textwrap.dedent(
                """class C(object):
                    def f(x):
                        return len(f)"""
                )
            )

        self.assertEqual(
            set(['object', 'len', 'f']),
            PyAstFreeVariableAnalyses.getFreeVariables(tree)
            )

    def test_freeVariables_functionCalls(self):
        tree = ast.parse(
            textwrap.dedent(
                """
                x = 2
                f(x, y, z = 2, w = x, q = free, *args, **kwargs)
                """
                )
            )

        self.assertEqual(
            set(['f', 'y', 'args', 'kwargs', 'free']),
            PyAstFreeVariableAnalyses.getFreeVariables(tree)
            )

    def test_freeVariables_ListComp_3(self):
        tree = ast.parse(
            textwrap.dedent(
                """
                x = [1,2,3]
                [y for val in x]
                """
                )
            )

        self.assertEqual(
            set(['y']),
            PyAstFreeVariableAnalyses.getFreeVariables(tree)
            )

 def test_freeVariables_name_substring_bug(self):
     tree = ast.parse(
         textwrap.dedent(
             """
             al = 10
             l
             """
             )
         )
     expectedResult = set(['l'])
     self.assertEqual(
         expectedResult,
         PyAstFreeVariableAnalyses.getFreeVariables(tree)
         )

 def test_freeVariables_withStatement(self):
     tree = ast.parse(
         textwrap.dedent(
             """
             def f(arg):
                 with x as e:
                     return e
             """
             )
         )
     self.assertEqual(
         set(['x']),
         PyAstFreeVariableAnalyses.getFreeVariables(tree)
         )