Python: Ensure no cross-talk in global tests

By giving all variables unique names

I also added a comment with the function name from the normal tests, so
its' easily visible what these tests are testing

python/ql/test/experimental/dataflow/fieldflow/test_global.py

@@ -44,100 +44,99 @@ def setFoo(obj, x):
     SINK_F(obj.foo)
     obj.foo = x
 
-
-myobj = MyObj("OK")
-
-setFoo(myobj, SOURCE)
-SINK(myobj.foo) # $ flow="SOURCE, l:-1 -> myobj.foo"
+# def test_indirect_assign():
+myobj1 = MyObj("OK")
+setFoo(myobj1, SOURCE)
+SINK(myobj1.foo) # $ flow="SOURCE, l:-1 -> myobj1.foo"
 
 
-
-myobj = MyObj("OK")
-
-myobj.setFoo(SOURCE)
-SINK(myobj.foo) # $ flow="SOURCE, l:-1 -> myobj.foo"
+# def test_indirect_assign_method():
+myobj2 = MyObj("OK")
+myobj2.setFoo(SOURCE)
+SINK(myobj2.foo) # $ flow="SOURCE, l:-1 -> myobj2.foo"
 
 
-
-myobj = MyObj(NONSOURCE)
-myobj.foo = SOURCE
-SINK(myobj.foo) # $ flow="SOURCE, l:-1 -> myobj.foo"
+# def test_direct_assign():
+myobj3 = MyObj(NONSOURCE)
+myobj3.foo = SOURCE
+SINK(myobj3.foo) # $ flow="SOURCE, l:-1 -> myobj3.foo"
 
 
+# def test_direct_assign_overwrite():
+myobj4 = MyObj(NONSOURCE)
+myobj4.foo = SOURCE
+myobj4.foo = NONSOURCE
+SINK_F(myobj4.foo)
 
-myobj = MyObj(NONSOURCE)
-myobj.foo = SOURCE
-myobj.foo = NONSOURCE
-SINK_F(myobj.foo)
-
+# def test_direct_if_assign(cond = False):
 
 # this way, our analysis isn't able to understand that `cond` is just False,
 # and therefore isn't able to determine that the if below will not hold.
 cond = eval("False")
 
-myobj = MyObj(NONSOURCE)
-myobj.foo = SOURCE
+myobj5 = MyObj(NONSOURCE)
+myobj5.foo = SOURCE
 if cond:
-    myobj.foo = NONSOURCE
-    SINK_F(myobj.foo)
+    myobj5.foo = NONSOURCE
+    SINK_F(myobj5.foo)
 # SPLITTING happens here, so in one version there is flow, and in the other there isn't
 # that's why it has both a flow and a MISSING: flow annotation
-SINK(myobj.foo) # $ flow="SOURCE, l:-6 -> myobj.foo" MISSING: flow
+SINK(myobj5.foo) # $ flow="SOURCE, l:-6 -> myobj5.foo" MISSING: flow
 
 
-
-myobj = MyObj(NONSOURCE)
-myobj.foo = SOURCE
+# def test_direct_if_always_assign(cond = True):
+myobj6 = MyObj(NONSOURCE)
+myobj6.foo = SOURCE
 if cond:
-    myobj.foo = NONSOURCE
-    SINK_F(myobj.foo)
+    myobj6.foo = NONSOURCE
+    SINK_F(myobj6.foo)
 else:
-    myobj.foo = NONSOURCE
-    SINK_F(myobj.foo)
-SINK_F(myobj.foo)
+    myobj6.foo = NONSOURCE
+    SINK_F(myobj6.foo)
+SINK_F(myobj6.foo)
 
 
-
-myobj = MyObj(NONSOURCE)
-myobj.foo = SOURCE
-SINK(getattr(myobj, "foo")) # $ flow="SOURCE, l:-1 -> getattr(..)"
+# def test_getattr():
+myobj7 = MyObj(NONSOURCE)
+myobj7.foo = SOURCE
+SINK(getattr(myobj7, "foo")) # $ flow="SOURCE, l:-1 -> getattr(..)"
 
 
-
-myobj = MyObj(NONSOURCE)
-setattr(myobj, "foo", SOURCE)
-SINK(myobj.foo) # $ flow="SOURCE, l:-1 -> myobj.foo"
+# def test_setattr():
+myobj8 = MyObj(NONSOURCE)
+setattr(myobj8, "foo", SOURCE)
+SINK(myobj8.foo) # $ flow="SOURCE, l:-1 -> myobj8.foo"
 
 
-
-myobj = MyObj(NONSOURCE)
-setattr(myobj, "foo", SOURCE)
-SINK(getattr(myobj, "foo")) # $ flow="SOURCE, l:-1 -> getattr(..)"
+# def test_setattr_getattr():
+myobj9 = MyObj(NONSOURCE)
+setattr(myobj9, "foo", SOURCE)
+SINK(getattr(myobj9, "foo")) # $ flow="SOURCE, l:-1 -> getattr(..)"
 
 
-
-myobj = MyObj(NONSOURCE)
-setattr(myobj, "foo", SOURCE)
-setattr(myobj, "foo", NONSOURCE)
-SINK_F(getattr(myobj, "foo"))
-
+# def test_setattr_getattr_overwrite():
+myobj10 = MyObj(NONSOURCE)
+setattr(myobj10, "foo", SOURCE)
+setattr(myobj10, "foo", NONSOURCE)
+SINK_F(getattr(myobj10, "foo"))
 
 
+# def test_constructor_assign():
 obj2 = MyObj(SOURCE)
 SINK(obj2.foo) # $ flow="SOURCE, l:-1 -> obj2.foo"
 
 
-
+# def test_constructor_assign_kw():
 obj3 = MyObj(foo=SOURCE)
 SINK(obj3.foo) # $ flow="SOURCE, l:-1 -> obj3.foo"
 
 
-
 def fields_with_local_flow(x):
-    obj = MyObj(x)
-    a = obj.foo
-    return a
+    obj0 = MyObj(x)
+    a0 = obj0.foo
+    return a0
 
+# def test_fields():
 SINK(fields_with_local_flow(SOURCE)) # $ flow="SOURCE -> fields_with_local_flow(..)"
 
 # ------------------------------------------------------------------------------
@@ -151,17 +150,19 @@ class NestedObj(object):
     def getObj(self):
         return self.obj
 
-x = SOURCE
-a = NestedObj()
-a.obj.foo = x
-SINK(a.obj.foo) # $ flow="SOURCE, l:-3 -> a.obj.foo"
+
+# def test_nested_obj():
+x1 = SOURCE
+a1 = NestedObj()
+a1.obj.foo = x1
+SINK(a1.obj.foo) # $ flow="SOURCE, l:-3 -> a1.obj.foo"
 
 
-
-x = SOURCE
-a = NestedObj()
-a.getObj().foo = x
-SINK(a.obj.foo) # $ flow="SOURCE, l:-3 -> a.obj.foo"
+# def test_nested_obj_method():
+x2 = SOURCE
+a2 = NestedObj()
+a2.getObj().foo = x2
+SINK(a2.obj.foo) # $ flow="SOURCE, l:-3 -> a2.obj.foo"
 
 # ------------------------------------------------------------------------------
 # Global scope interaction