Reduce compilation warnings in tests.

Author: fangerer

graalpython/com.oracle.graal.python.test/src/tests/cpyext/__init__.py

@@ -36,25 +36,26 @@
 # SOFTWARE.
 
 import sys
-#from _ast import arguments
 os = sys.modules.get("posix", sys.modules.get("nt", None))
 if os is None:
     raise ImportError("posix or nt module is required in builtin modules")
 __dir__ = __file__.rpartition("/")[0]
 
-
 GRAALPYTHON = sys.implementation.name == "graalpython"
 
+
 def unhandled_error_compare(x, y):
-    if (isinstance(x,BaseException) and isinstance(y,BaseException)):
+    if (isinstance(x, BaseException) and isinstance(y, BaseException)):
         return type(x) == type(y)
     else:
         return x == y
 
+
 class CPyExtTestCase():
+
     def setUp(self):
         for typ in type(self).mro():
-            for k,v in typ.__dict__.items():
+            for k, v in typ.__dict__.items():
                 if k.startswith("test_"):
                     modname = k.replace("test_", "")
                     if k.startswith("test_graalpython_"):
@@ -67,15 +68,15 @@ def setUp(self):
 
 def ccompile(self, name):
     from distutils.core import setup, Extension
-    module = Extension(name, sources = ['%s/%s.c' % (__dir__, name)])
+    module = Extension(name, sources=['%s/%s.c' % (__dir__, name)])
     args = ['--quiet', 'build', 'install_lib', '-f', '--install-dir=%s' % __dir__]
     setup(
-        script_name = 'setup',
-        script_args = args,
-        name = name,
-        version = '1.0',
-        description = '',
-        ext_modules = [module]
+        script_name='setup',
+        script_args=args,
+        name=name,
+        version='1.0',
+        description='',
+        ext_modules=[module]
     )
 
 
@@ -185,7 +186,7 @@ def ccompile(self, name):
     PyObject* ___arg;
     {argumentdeclarations};
     {resultvardeclarations}
-    void* res;
+    {resulttype} res;
 
     if (!PyArg_ParseTuple(args, "O", &___arg)) {{
         return NULL;
@@ -202,7 +203,7 @@ def ccompile(self, name):
     }}
 #endif
     
-    res = (void *){callfunction}({argumentnames}{resultvarlocations});
+    res = {callfunction}({argumentnames}{resultvarlocations});
 
     return Py_BuildValue("{resultspec}", res {resultvarnames});
 }}
@@ -228,15 +229,17 @@ def ccompile(self, name):
 }}
 """
 
+
 class CPyExtFunction():
+
     def __init__(self, pfunc, parameters, template=c_template, cmpfunc=None, **kwargs):
         self.template = template
         self.pfunc = pfunc
         self.parameters = parameters
         kwargs["name"] = kwargs["name"] if "name" in kwargs else None
         self.name = kwargs["name"]
         if "code" in kwargs:
-            kwargs["customcode"] = kwargs["code"] 
+            kwargs["customcode"] = kwargs["code"]
             del kwargs["code"]
         else:
             kwargs["customcode"] = ""
@@ -286,7 +289,7 @@ def _insert(self, d, name, default_value):
 
     def __repr__(self):
         return "<CPyExtFunction %s>" % self.name
-    
+
     def test(self):
         sys.path.insert(0, __dir__)
         try:
@@ -327,10 +330,11 @@ class CPyExtFunctionOutVars(CPyExtFunction):
     This class supports this.
     Set 'resultvars' to declare the output vars.
     '''
+
     def __init__(self, pfunc, parameters, template=c_template_multi_res, **kwargs):
         super(CPyExtFunctionOutVars, self).__init__(pfunc, parameters, **kwargs)
         self.template = template
-    
+
     def create_module(self, name=None):
         fargs = self.formatargs
         if "resultvars" not in fargs:
@@ -348,26 +352,28 @@ def create_module(self, name=None):
                 fargs["resultvarnames"] = ""
         if len(fargs["resultvarnames"]) and not fargs["resultvarnames"].startswith(","):
             fargs["resultvarnames"] = ", " + fargs["resultvarnames"]
-            
+
         if "resultvarlocations" not in fargs:
                     fargs["resultvarlocations"] = ", ".join("&" + arg.rpartition(" ")[2] for arg in fargs["resultvars"])
+        if "resulttype" not in fargs:
+                    fargs["resulttype"] = "void*"
         if len(fargs["resultvarlocations"]):
             fargs["resultvarlocations"] = ", " + fargs["resultvarlocations"]
         self._insert(fargs, "customcode", "")
         super(CPyExtFunctionOutVars, self).create_module(name)
 
 
 class CPyExtFunctionVoid(CPyExtFunction):
+
     def __init__(self, pfunc, parameters, template=c_template_void, **kwargs):
         super(CPyExtFunctionVoid, self).__init__(pfunc, parameters, **kwargs)
         self.template = template
-    
+
     def create_module(self, name=None):
         fargs = self.formatargs
         if "resultval" not in fargs:
             fargs["resultval"] = "Py_None"
         super(CPyExtFunctionVoid, self).create_module(name)
 
 
-
 CPyExtTestCase.compile_module = ccompile

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_bytes.py

@@ -56,7 +56,9 @@ def _reference_format(args):
     fmt_args = tuple(args[1:])
     return (fmt % fmt_args).encode()
 
+
 class TestPyBytes(CPyExtTestCase):
+
     def compile_module(self, name):
         type(self).mro()[1].__dict__["test_%s" % name].create_module(name)
         super(TestPyBytes, self).compile_module(name)
@@ -84,7 +86,7 @@ def compile_module(self, name):
     # PyBytes_AsString
     test_PyBytes_AsString = CPyExtFunction(
         lambda b: b[0].decode(),
-        lambda: ((b"hello", ), (b"world",)),
+        lambda: ((b"hello",), (b"world",)),
         resultspec="s",
         argspec="O",
         arguments=["PyObject* arg"],
@@ -98,12 +100,13 @@ def compile_module(self, name):
         argspec="O",
         arguments=["PyObject* arg"],
         resultvars=("char* s", "Py_ssize_t sz"),
+        resulttype="int"
     )
 
     # PyBytes_Size
     test_PyBytes_Size = CPyExtFunction(
         lambda b: len(b[0]),
-        lambda: ((b"hello", ), (b"hello world",), (b"",)),
+        lambda: ((b"hello",), (b"hello world",), (b"",)),
         resultspec="n",
         argspec="O",
         arguments=["PyObject* arg"],
@@ -112,7 +115,7 @@ def compile_module(self, name):
     # PyBytes_GET_SIZE
     test_PyBytes_GET_SIZE = CPyExtFunction(
         lambda b: len(b[0]),
-        lambda: ((b"hello", ), (b"hello world",), (b"",)),
+        lambda: ((b"hello",), (b"hello world",), (b"",)),
         resultspec="n",
         argspec="O",
         arguments=["PyObject* arg"],
@@ -122,7 +125,7 @@ def compile_module(self, name):
     # PyBytes_FromFormat
     test_PyBytes_FromFormat = CPyExtFunction(
         _reference_format,
-        lambda: (("hello %s %s, %d times", "beautiful", "world", 3), ),
+        lambda: (("hello %s %s, %d times", "beautiful", "world", 3),),
         resultspec="O",
         argspec="sssi",
         arguments=["char* fmt", "char* arg0", "char* arg1", "int arg2"],
@@ -145,6 +148,7 @@ def compile_module(self, name):
         resultspec="iO",
         argspec="OO",
         arguments=["PyObject* arg0", "PyObject* arg1"],
+        resulttype="int",
         argumentnames="&arg0, arg1",
         resultvarnames="arg0",
         callfunction="wrap_PyBytes_Concat"
@@ -167,6 +171,7 @@ def compile_module(self, name):
         resultspec="iO",
         argspec="OO",
         arguments=["PyObject* arg0", "PyObject* arg1"],
+        resulttype="int",
         argumentnames="&arg0, arg1",
         resultvarnames="arg0",
         callfunction="wrap_PyBytes_ConcatAndDel"
@@ -206,9 +211,9 @@ def compile_module(self, name):
     test_PyBytes_AS_STRING = CPyExtFunction(
         lambda b: b[0].decode("utf-8"),
         lambda: (
-            (b"hello", ), 
-            ("hellö".encode("utf-8"), ), 
-            (b"hello world",), 
+            (b"hello",),
+            ("hellö".encode("utf-8"),),
+            (b"hello world",),
             (b"",)
         ),
         resultspec="s",

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_capsule.py

@@ -39,18 +39,20 @@
 from . import CPyExtTestCase, CPyExtFunction, CPyExtFunctionOutVars, unhandled_error_compare, GRAALPYTHON
 __dir__ = __file__.rpartition("/")[0]
 
+
 class TestPyCapsule(CPyExtTestCase):
+
     def compile_module(self, name):
         type(self).mro()[1].__dict__["test_%s" % name].create_module(name)
         super(TestPyCapsule, self).compile_module(name)
 
     test_PyCapsule_CheckExact = CPyExtFunction(
         lambda args: True,
         lambda: (
-            ("hello",0xDEADBEEF), 
+            ("hello", 0xDEADBEEF),
         ),
         code='''int wrap_PyCapsule_Check(char * name, Py_ssize_t ptr) {
-            PyObject* capsule = PyCapsule_New(ptr, name, NULL);
+            PyObject* capsule = PyCapsule_New((void *)ptr, name, NULL);
             return PyCapsule_CheckExact(capsule);
         }
         ''',

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_dict.py

@@ -40,7 +40,6 @@
 __dir__ = __file__.rpartition("/")[0]
 
 
-
 def _reference_get_item(args):
     try:
         d = args[0]
@@ -92,7 +91,9 @@ def _reference_copy(args):
 class SubDict(dict):
     pass
 
+
 class TestPyDict(CPyExtTestCase):
+
     def compile_module(self, name):
         type(self).mro()[1].__dict__["test_%s" % name].create_module(name)
         super(TestPyDict, self).compile_module(name)
@@ -155,6 +156,7 @@ def compile_module(self, name):
         resultspec="O",
         argspec='OsO',
         arguments=("PyObject* dict", "char* key", "PyObject* defaultValue"),
+        resulttype="PyObject*",
         callfunction="wrap_PyDict_GetItemString",
         cmpfunc=unhandled_error_compare
     )
@@ -172,8 +174,8 @@ def compile_module(self, name):
     # PyDict_Next
     test_PyDict_Next = CPyExtFunctionOutVars(
         _reference_next,
-        #lambda: (({'a': "hello"}, 0), ({'a': "hello", 'b': 'world'}, 1), ({'a': "hello"}, 1)),
-        lambda: (({'a': "hello"}, 1), ),
+        # lambda: (({'a': "hello"}, 0), ({'a': "hello", 'b': 'world'}, 1), ({'a': "hello"}, 1)),
+        lambda: (({'a': "hello"}, 1),),
         code='''int wrap_PyDict_Next(PyObject* dict, Py_ssize_t* ppos, PyObject** key, PyObject** value) {
             int res = 0;
             Py_ssize_t iterations = *ppos;
@@ -196,6 +198,7 @@ def compile_module(self, name):
         resultspec="iOO",
         argspec='On',
         arguments=("PyObject* dict", "Py_ssize_t ppos"),
+        resulttype="int",
         argumentnames=("dict, &ppos"),
         resultvars=("PyObject* key", "PyObject* value"),
         callfunction="wrap_PyDict_Next",
@@ -229,7 +232,7 @@ def compile_module(self, name):
     # PyDict_Contains
     test_PyDict_Contains = CPyExtFunction(
         lambda args: int(args[1] in args[0]),
-        lambda: (({},"a"), ({'a': "hello"},"a"), ({'a': "hello"},"b")),
+        lambda: (({}, "a"), ({'a': "hello"}, "a"), ({'a': "hello"}, "b")),
         resultspec="i",
         argspec='OO',
         arguments=["PyObject* dict", "PyObject* key"],
@@ -238,8 +241,8 @@ def compile_module(self, name):
     test_PyDict_Check = CPyExtFunction(
         lambda args: isinstance(args[0], dict),
         lambda: (
-            ({},), 
-            ({'a': "hello"},), 
+            ({},),
+            ({'a': "hello"},),
             (dict(),),
             ("not a dict",),
             (3,),
@@ -255,8 +258,8 @@ def compile_module(self, name):
     test_PyDict_CheckExact = CPyExtFunction(
         lambda args: type(args[0]) is dict,
         lambda: (
-            ({},), 
-            ({'a': "hello"},), 
+            ({},),
+            ({'a': "hello"},),
             (dict(),),
             ("not a dict",),
             (3,),

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_float.py

@@ -41,10 +41,11 @@
 
 
 def _float_compare(x, y):
+
     def isNan(x):
         return isinstance(x, float) and x != x
 
-    if (isinstance(x,BaseException) and isinstance(y,BaseException)):
+    if (isinstance(x, BaseException) and isinstance(y, BaseException)):
         return type(x) == type(y)
     else:
         # either equal or both are NaN
@@ -69,31 +70,33 @@ class DummyNonFloat():
 
 
 class DummyFloatable():
+
     def __float__(self):
         return 3.14159
 
 
 class DummyFloatSubclass(float):
+
     def __float__(self):
         return 2.71828
 
 
 class TestPyFloat(CPyExtTestCase):
+
     def compile_module(self, name):
         type(self).mro()[1].__dict__["test_%s" % name].create_module(name)
         super(TestPyFloat, self).compile_module(name)
 
-
     test_PyFloat_AsDouble = CPyExtFunctionOutVars(
         lambda args: True,
         lambda: (
             (float(0.0), 0.0),
-            (float(-1.0),-1.0),
-            (float(0xffffffffffffffffffffffff),0xffffffffffffffffffffffff),
-            (float('nan'),float('nan')),
-            (DummyFloatable(),3.14159),
-            (DummyFloatSubclass(),0.0),
-            (DummyNonFloat(),-1.0),
+            (float(-1.0), -1.0),
+            (float(0xffffffffffffffffffffffff), 0xffffffffffffffffffffffff),
+            (float('nan'), float('nan')),
+            (DummyFloatable(), 3.14159),
+            (DummyFloatSubclass(), 0.0),
+            (DummyNonFloat(), -1.0),
         ),
         code='''int wrap_PyFloat_AsDouble(PyObject* obj, double expected) {
             double res = PyFloat_AsDouble(obj);
@@ -113,6 +116,7 @@ def compile_module(self, name):
         resultspec="i",
         argspec='Od',
         arguments=["PyObject* obj", "double expected"],
+        resulttype="int",
         callfunction="wrap_PyFloat_AsDouble",
     )