py: Inline expectation should have space before $

Author: owen-mc

python/ql/test/experimental/import-resolution/block_flow_check.py

@@ -5,7 +5,7 @@ class SOURCE(object):
     @staticmethod
     def block_flow(): pass
 
-check("SOURCE", SOURCE, SOURCE, globals()) #$ prints=SOURCE
+check("SOURCE", SOURCE, SOURCE, globals()) # $ prints=SOURCE
 
 SOURCE.block_flow()
 

python/ql/test/experimental/import-resolution/foo.py

@@ -8,7 +8,7 @@
 __private_foo_attr = "__private_foo_attr"
 
 # A reexport of bar under a new name. Used in main.py
-import bar as bar_reexported #$ imports=bar as=bar_reexported
-check("bar_reexported.bar_attr", bar_reexported.bar_attr, "bar_attr", globals()) #$ prints=bar_attr
+import bar as bar_reexported # $ imports=bar as=bar_reexported
+check("bar_reexported.bar_attr", bar_reexported.bar_attr, "bar_attr", globals()) # $ prints=bar_attr
 
 exit(__file__)

python/ql/test/experimental/import-resolution/generous_export.py

@@ -5,7 +5,7 @@ class SOURCE(object):
     @staticmethod
     def block_flow(): pass
 
-check("SOURCE", SOURCE, SOURCE, globals()) #$ prints=SOURCE
+check("SOURCE", SOURCE, SOURCE, globals()) # $ prints=SOURCE
 
 if eval("False"):
     # With our current import resolution, this value for SOURCE will be considered to be

python/ql/test/experimental/import-resolution/if_then_else_refined.py

@@ -14,6 +14,6 @@ class SOURCE(): pass
 
 src.foo = 42
 
-check("src", src, src, globals()) #$ prints=SOURCE
+check("src", src, src, globals()) # $ prints=SOURCE
 
 exit(__file__)

python/ql/test/experimental/import-resolution/main.py

@@ -24,76 +24,76 @@
 enter(__file__)
 
 # A simple import. Binds foo to the foo module
-import foo #$ imports=foo as=foo
-check("foo.foo_attr", foo.foo_attr, "foo_attr", globals()) #$ prints=foo_attr
+import foo # $ imports=foo as=foo
+check("foo.foo_attr", foo.foo_attr, "foo_attr", globals()) # $ prints=foo_attr
 
 # Private attributes are still accessible.
-check("foo.__private_foo_attr", foo.__private_foo_attr, "__private_foo_attr", globals()) #$ prints=__private_foo_attr
+check("foo.__private_foo_attr", foo.__private_foo_attr, "__private_foo_attr", globals()) # $ prints=__private_foo_attr
 
 # An aliased import, binding foo to foo_alias
-import foo as foo_alias #$ imports=foo as=foo_alias
-check("foo_alias.foo_attr", foo_alias.foo_attr, "foo_attr", globals()) #$ prints=foo_attr
+import foo as foo_alias # $ imports=foo as=foo_alias
+check("foo_alias.foo_attr", foo_alias.foo_attr, "foo_attr", globals()) # $ prints=foo_attr
 
 # A reference to a reexported module
-check("foo.bar_reexported", foo.bar_reexported, "<module bar>", globals()) #$ prints="<module bar>"
-check("foo.bar_reexported.bar_attr", foo.bar_reexported.bar_attr, "bar_attr", globals()) #$ prints=bar_attr
+check("foo.bar_reexported", foo.bar_reexported, "<module bar>", globals()) # $ prints="<module bar>"
+check("foo.bar_reexported.bar_attr", foo.bar_reexported.bar_attr, "bar_attr", globals()) # $ prints=bar_attr
 
 # A simple "import from" statement.
 from bar import bar_attr
-check("bar_attr", bar_attr, "bar_attr", globals()) #$ prints=bar_attr
+check("bar_attr", bar_attr, "bar_attr", globals()) # $ prints=bar_attr
 
 # Importing an attribute from a subpackage of a package.
 from package.subpackage import subpackage_attr
-check("subpackage_attr", subpackage_attr, "subpackage_attr", globals()) #$ prints=subpackage_attr
+check("subpackage_attr", subpackage_attr, "subpackage_attr", globals()) # $ prints=subpackage_attr
 
 # Importing a package attribute under an alias.
 from package import package_attr as package_attr_alias
-check("package_attr_alias", package_attr_alias,  "package_attr", globals()) #$ prints=package_attr
+check("package_attr_alias", package_attr_alias,  "package_attr", globals()) # $ prints=package_attr
 
 # Importing a subpackage under an alias.
-from package import subpackage as aliased_subpackage #$ imports=package.subpackage.__init__ as=aliased_subpackage
-check("aliased_subpackage.subpackage_attr", aliased_subpackage.subpackage_attr, "subpackage_attr", globals()) #$ prints=subpackage_attr
+from package import subpackage as aliased_subpackage # $ imports=package.subpackage.__init__ as=aliased_subpackage
+check("aliased_subpackage.subpackage_attr", aliased_subpackage.subpackage_attr, "subpackage_attr", globals()) # $ prints=subpackage_attr
 
 def local_import():
     # Same as above, but in a local scope.
-    import package.subpackage as local_subpackage #$ imports=package.subpackage.__init__ as=local_subpackage
-    check("local_subpackage.subpackage_attr", local_subpackage.subpackage_attr, "subpackage_attr", locals()) #$ prints=subpackage_attr
+    import package.subpackage as local_subpackage # $ imports=package.subpackage.__init__ as=local_subpackage
+    check("local_subpackage.subpackage_attr", local_subpackage.subpackage_attr, "subpackage_attr", locals()) # $ prints=subpackage_attr
 
 local_import()
 
 # Importing a subpacking using `import` and binding it to a name.
-import package.subpackage as aliased_subpackage #$ imports=package.subpackage.__init__ as=aliased_subpackage
-check("aliased_subpackage.subpackage_attr", aliased_subpackage.subpackage_attr, "subpackage_attr", globals()) #$ prints=subpackage_attr
+import package.subpackage as aliased_subpackage # $ imports=package.subpackage.__init__ as=aliased_subpackage
+check("aliased_subpackage.subpackage_attr", aliased_subpackage.subpackage_attr, "subpackage_attr", globals()) # $ prints=subpackage_attr
 
 # Importing without binding instead binds the top level name.
-import package.subpackage #$ imports=package.__init__ as=package
-check("package.package_attr", package.package_attr, "package_attr", globals()) #$ prints=package_attr
+import package.subpackage # $ imports=package.__init__ as=package
+check("package.package_attr", package.package_attr, "package_attr", globals()) # $ prints=package_attr
 
 # Deep imports
-import package.subpackage.submodule #$ imports=package.__init__ as=package
-check("package.subpackage.submodule.submodule_attr", package.subpackage.submodule.submodule_attr, "submodule_attr", globals()) #$ prints=submodule_attr
+import package.subpackage.submodule # $ imports=package.__init__ as=package
+check("package.subpackage.submodule.submodule_attr", package.subpackage.submodule.submodule_attr, "submodule_attr", globals()) # $ prints=submodule_attr
 
 
 if sys.version_info[0] == 3:
     # Importing from a namespace module.
     from namespace_package.namespace_module import namespace_module_attr
-    check("namespace_module_attr", namespace_module_attr, "namespace_module_attr", globals()) #$ prints3=namespace_module_attr
+    check("namespace_module_attr", namespace_module_attr, "namespace_module_attr", globals()) # $ prints3=namespace_module_attr
 
 
-from attr_clash import clashing_attr, non_clashing_submodule #$ imports=attr_clash.clashing_attr as=clashing_attr imports=attr_clash.non_clashing_submodule as=non_clashing_submodule
-check("clashing_attr", clashing_attr, "clashing_attr", globals()) #$ prints=clashing_attr SPURIOUS: prints="<module attr_clash.clashing_attr>"
-check("non_clashing_submodule", non_clashing_submodule, "<module attr_clash.non_clashing_submodule>", globals()) #$ prints="<module attr_clash.non_clashing_submodule>"
+from attr_clash import clashing_attr, non_clashing_submodule # $ imports=attr_clash.clashing_attr as=clashing_attr imports=attr_clash.non_clashing_submodule as=non_clashing_submodule
+check("clashing_attr", clashing_attr, "clashing_attr", globals()) # $ prints=clashing_attr SPURIOUS: prints="<module attr_clash.clashing_attr>"
+check("non_clashing_submodule", non_clashing_submodule, "<module attr_clash.non_clashing_submodule>", globals()) # $ prints="<module attr_clash.non_clashing_submodule>"
 
-import attr_clash.clashing_attr as _doesnt_matter #$ imports=attr_clash.clashing_attr as=_doesnt_matter
-from attr_clash import clashing_attr, non_clashing_submodule #$ imports=attr_clash.clashing_attr as=clashing_attr imports=attr_clash.non_clashing_submodule as=non_clashing_submodule
-check("clashing_attr", clashing_attr, "<module attr_clash.clashing_attr>", globals()) #$ prints="<module attr_clash.clashing_attr>" SPURIOUS: prints=clashing_attr
+import attr_clash.clashing_attr as _doesnt_matter # $ imports=attr_clash.clashing_attr as=_doesnt_matter
+from attr_clash import clashing_attr, non_clashing_submodule # $ imports=attr_clash.clashing_attr as=clashing_attr imports=attr_clash.non_clashing_submodule as=non_clashing_submodule
+check("clashing_attr", clashing_attr, "<module attr_clash.clashing_attr>", globals()) # $ prints="<module attr_clash.clashing_attr>" SPURIOUS: prints=clashing_attr
 
 # check that import * only imports the __all__ attributes
 from has_defined_all import *
-check("all_defined_foo", all_defined_foo, "all_defined_foo", globals()) #$ prints=all_defined_foo
+check("all_defined_foo", all_defined_foo, "all_defined_foo", globals()) # $ prints=all_defined_foo
 
 try:
-    check("all_defined_bar", all_defined_bar, "all_defined_bar", globals()) #$ SPURIOUS: prints=all_defined_bar
+    check("all_defined_bar", all_defined_bar, "all_defined_bar", globals()) # $ SPURIOUS: prints=all_defined_bar
     raise Exception("Did not get expected NameError")
 except NameError as e:
     if "all_defined_bar" in str(e):
@@ -102,15 +102,15 @@ def local_import():
         raise
 
 import has_defined_all # $ imports=has_defined_all as=has_defined_all
-check("has_defined_all.all_defined_foo", has_defined_all.all_defined_foo, "all_defined_foo", globals()) #$ prints=all_defined_foo
-check("has_defined_all.all_defined_bar", has_defined_all.all_defined_bar, "all_defined_bar", globals()) #$ prints=all_defined_bar
+check("has_defined_all.all_defined_foo", has_defined_all.all_defined_foo, "all_defined_foo", globals()) # $ prints=all_defined_foo
+check("has_defined_all.all_defined_bar", has_defined_all.all_defined_bar, "all_defined_bar", globals()) # $ prints=all_defined_bar
 
 # same check as above, but going through one level of indirection (which can make a difference)
 from has_defined_all_indirection import *
-check("all_defined_foo_copy", all_defined_foo_copy, "all_defined_foo_copy", globals()) #$ prints=all_defined_foo_copy
+check("all_defined_foo_copy", all_defined_foo_copy, "all_defined_foo_copy", globals()) # $ prints=all_defined_foo_copy
 
 try:
-    check("all_defined_bar_copy", all_defined_bar_copy, "all_defined_bar_copy", globals()) #$ SPURIOUS: prints=all_defined_bar_copy
+    check("all_defined_bar_copy", all_defined_bar_copy, "all_defined_bar_copy", globals()) # $ SPURIOUS: prints=all_defined_bar_copy
     raise Exception("Did not get expected NameError")
 except NameError as e:
     if "all_defined_bar_copy" in str(e):
@@ -120,7 +120,7 @@ def local_import():
 
 # same check as above, but going through one level of indirection (which can make a difference)
 import has_defined_all_indirection # $ imports=has_defined_all_indirection as=has_defined_all_indirection
-check("has_defined_all_indirection.all_defined_foo_copy", has_defined_all_indirection.all_defined_foo_copy, "all_defined_foo_copy", globals()) #$ prints=all_defined_foo_copy
+check("has_defined_all_indirection.all_defined_foo_copy", has_defined_all_indirection.all_defined_foo_copy, "all_defined_foo_copy", globals()) # $ prints=all_defined_foo_copy
 
 try:
     check("has_defined_all_indirection.all_defined_bar_copy", has_defined_all_indirection.all_defined_bar_copy, "all_defined_bar_copy", globals())
@@ -133,30 +133,30 @@ def local_import():
 
 # check that import * from an __init__ file works
 from package.subpackage2 import *
-check("subpackage2_attr", subpackage2_attr, "subpackage2_attr", globals()) #$ prints=subpackage2_attr
+check("subpackage2_attr", subpackage2_attr, "subpackage2_attr", globals()) # $ prints=subpackage2_attr
 
 # check that definitions from within if-then-else are found
 from if_then_else import if_then_else_defined
-check("if_then_else_defined", if_then_else_defined, "if_defined", globals()) #$ prints=if_defined prints=else_defined_1 prints=else_defined_2
+check("if_then_else_defined", if_then_else_defined, "if_defined", globals()) # $ prints=if_defined prints=else_defined_1 prints=else_defined_2
 
 # check that refined definitions are handled correctly
 import refined # $ imports=refined as=refined
-check("refined.SOURCE", refined.SOURCE, refined.SOURCE, globals()) #$ prints=SOURCE
+check("refined.SOURCE", refined.SOURCE, refined.SOURCE, globals()) # $ prints=SOURCE
 
 import if_then_else_refined # $ imports=if_then_else_refined as=if_then_else_refined
-check("if_then_else_refined.src", if_then_else_refined.src, if_then_else_refined.src, globals()) #$ prints=SOURCE
+check("if_then_else_refined.src", if_then_else_refined.src, if_then_else_refined.src, globals()) # $ prints=SOURCE
 
 import simplistic_reexport # $ imports=simplistic_reexport as=simplistic_reexport
-check("simplistic_reexport.bar_attr", simplistic_reexport.bar_attr, "overwritten", globals()) #$ prints=overwritten SPURIOUS: prints=bar_attr
-check("simplistic_reexport.baz_attr", simplistic_reexport.baz_attr, "overwritten", globals()) #$ prints=overwritten SPURIOUS: prints=baz_attr
+check("simplistic_reexport.bar_attr", simplistic_reexport.bar_attr, "overwritten", globals()) # $ prints=overwritten SPURIOUS: prints=bar_attr
+check("simplistic_reexport.baz_attr", simplistic_reexport.baz_attr, "overwritten", globals()) # $ prints=overwritten SPURIOUS: prints=baz_attr
 
 # check that we don't treat all assignments as being exports
-import block_flow_check #$ imports=block_flow_check as=block_flow_check
+import block_flow_check # $ imports=block_flow_check as=block_flow_check
 check("block_flow_check.SOURCE", block_flow_check.SOURCE, block_flow_check.SOURCE, globals())
 
 # show that import resolution is a bit too generous with definitions
-import generous_export #$ imports=generous_export as=generous_export
-check("generous_export.SOURCE", generous_export.SOURCE, generous_export.SOURCE, globals()) #$ SPURIOUS: prints=SOURCE
+import generous_export # $ imports=generous_export as=generous_export
+check("generous_export.SOURCE", generous_export.SOURCE, generous_export.SOURCE, globals()) # $ SPURIOUS: prints=SOURCE
 
 exit(__file__)
 

python/ql/test/experimental/import-resolution/package/subpackage/__init__.py

@@ -5,10 +5,10 @@
 
 # Importing an attribute from the parent package.
 from .. import attr_used_in_subpackage as imported_attr
-check("imported_attr", imported_attr,  "attr_used_in_subpackage", globals()) #$ prints=attr_used_in_subpackage
+check("imported_attr", imported_attr,  "attr_used_in_subpackage", globals()) # $ prints=attr_used_in_subpackage
 
 # Importing an irrelevant attribute from a sibling module binds the name to the module.
 from .submodule import irrelevant_attr
-check("submodule.submodule_attr", submodule.submodule_attr, "submodule_attr", globals()) #$ MISSING:prints=submodule_attr
+check("submodule.submodule_attr", submodule.submodule_attr, "submodule_attr", globals()) # $ MISSING:prints=submodule_attr
 
 exit(__file__)

python/ql/test/experimental/import-resolution/refined.py

@@ -3,12 +3,12 @@
 
 class SOURCE(object): pass
 
-check("SOURCE", SOURCE, SOURCE, globals()) #$ prints=SOURCE
+check("SOURCE", SOURCE, SOURCE, globals()) # $ prints=SOURCE
 
 SOURCE.foo = 42
 SOURCE.bar = 43
 SOURCE.baz = 44
 
-check("SOURCE", SOURCE, SOURCE, globals()) #$ prints=SOURCE
+check("SOURCE", SOURCE, SOURCE, globals()) # $ prints=SOURCE
 
 exit(__file__)

python/ql/test/experimental/import-resolution/simplistic_reexport.py

@@ -4,16 +4,16 @@
 enter(__file__)
 
 from bar import bar_attr
-check("bar_attr", bar_attr, "bar_attr", globals()) #$ prints=bar_attr
+check("bar_attr", bar_attr, "bar_attr", globals()) # $ prints=bar_attr
 
 bar_attr = "overwritten"
-check("bar_attr", bar_attr, "overwritten", globals()) #$ prints=overwritten
+check("bar_attr", bar_attr, "overwritten", globals()) # $ prints=overwritten
 
 
 from baz import *
-check("baz_attr", baz_attr, "baz_attr", globals()) #$ MISSING: prints=baz_attr
+check("baz_attr", baz_attr, "baz_attr", globals()) # $ MISSING: prints=baz_attr
 
 baz_attr = "overwritten"
-check("baz_attr", baz_attr, "overwritten", globals()) #$ prints=overwritten
+check("baz_attr", baz_attr, "overwritten", globals()) # $ prints=overwritten
 
 exit(__file__)

python/ql/test/experimental/library-tests/CallGraph-type-annotations/type_annotations.py

@@ -3,7 +3,7 @@ def method(self):
         pass
 
 def test_parameter_annotation(x: Foo):
-    x.method() #$ tt=Foo.method
+    x.method() # $ tt=Foo.method
 
 def test_no_parameter_annotation(x):
     x.method()
@@ -12,21 +12,21 @@ def function_with_return_annotation() -> Foo:
     return eval("Foo()")
 
 def test_return_annotation():
-    x = function_with_return_annotation() #$ pt,tt=function_with_return_annotation
-    x.method() #$ tt=Foo.method
+    x = function_with_return_annotation() # $ pt,tt=function_with_return_annotation
+    x.method() # $ tt=Foo.method
 
 def function_without_return_annotation():
     return eval("Foo()")
 
 def test_no_return_annotation():
-    x = function_without_return_annotation() #$ pt,tt=function_without_return_annotation
+    x = function_without_return_annotation() # $ pt,tt=function_without_return_annotation
     x.method()
 
 def test_variable_annotation():
     x = eval("Foo()")
     x : Foo
     # Currently fails because there is no flow from the class definition to the type annotation.
-    x.method() #$ MISSING: tt=Foo.method
+    x.method() # $ MISSING: tt=Foo.method
 
 def test_no_variable_annotation():
     x = eval("Foo()")

python/ql/test/experimental/library-tests/CallGraph/code/self_passing.py

@@ -24,7 +24,7 @@ def foo(self):
         self.bar() # $ pt,tt=A.bar
 
     def not_called(self):
-        self.bar() #$ pt,tt=A.bar
+        self.bar() # $ pt,tt=A.bar
 
     def bar(self):
         print("A.bar")