[GR-18744] [GR-18756] [GR-16816] [GR-18813] [GR-18788] Various bug fixes.

PullRequest: graalpython/685

Author: fangerer

graalpython/com.oracle.graal.python.cext/include/Python.h

@@ -122,6 +122,7 @@
 #include "weakrefobject.h"
 #include "sysmodule.h"
 #include "fileutils.h"
+#include "pystrtod.h"
 
 // TODO: we must extend the refcounting behavior to support handles to managed objects
 #undef Py_DECREF

graalpython/com.oracle.graal.python.cext/include/pystrtod.h

@@ -0,0 +1,51 @@
+/* Copyright (c) 2019, Oracle and/or its affiliates.
+ * Copyright (C) 1996-2017 Python Software Foundation
+ *
+ * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+ */
+
+#ifndef Py_STRTOD_H
+#define Py_STRTOD_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+PyAPI_FUNC(double) PyOS_string_to_double(const char *str,
+                                         char **endptr,
+                                         PyObject *overflow_exception);
+
+/* The caller is responsible for calling PyMem_Free to free the buffer
+   that's is returned. */
+PyAPI_FUNC(char *) PyOS_double_to_string(double val,
+                                         char format_code,
+                                         int precision,
+                                         int flags,
+                                         int *type);
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) _Py_string_to_number_with_underscores(
+    const char *str, Py_ssize_t len, const char *what, PyObject *obj, void *arg,
+    PyObject *(*innerfunc)(const char *, Py_ssize_t, void *));
+
+PyAPI_FUNC(double) _Py_parse_inf_or_nan(const char *p, char **endptr);
+#endif
+
+
+/* PyOS_double_to_string's "flags" parameter can be set to 0 or more of: */
+#define Py_DTSF_SIGN      0x01 /* always add the sign */
+#define Py_DTSF_ADD_DOT_0 0x02 /* if the result is an integer add ".0" */
+#define Py_DTSF_ALT       0x04 /* "alternate" formatting. it's format_code
+                                  specific */
+
+/* PyOS_double_to_string's "type", if non-NULL, will be set to one of: */
+#define Py_DTST_FINITE 0
+#define Py_DTST_INFINITE 1
+#define Py_DTST_NAN 2
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_STRTOD_H */

graalpython/com.oracle.graal.python.cext/src/pystrtod.c

@@ -53,3 +53,19 @@ double PyOS_string_to_double(const char *s, char **endptr, PyObject *overflow_ex
 	}
 	return result;
 }
+
+/* translation macro to be independent of changes in 'pystrtod.h' */
+#define TRANSLATE_TYPE(__tc__) ((__tc__) == 0 ? Py_DTST_FINITE : ((__tc__) == 1 ? Py_DTST_INFINITE : Py_DTST_NAN))
+
+UPCALL_ID(PyTruffle_OS_DoubleToString);
+char * PyOS_double_to_string(double val, char format_code, int precision, int flags, int *type) {
+	char* result = NULL;
+	PyObject* resultTuple = UPCALL_CEXT_O(_jls_PyTruffle_OS_DoubleToString, val, (int32_t)format_code, precision, flags);
+	if (resultTuple != NULL) {
+		result = (char *) PyTuple_GetItem(resultTuple, 0);
+		if (type != NULL) {
+			*type = TRANSLATE_TYPE(as_int(PyTuple_GetItem(resultTuple, 1)));
+		}
+	}
+	return result;
+}

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

@@ -151,15 +151,14 @@ def file_not_empty(path):
         return NULL;
     }}
 
-    if (strlen("{argspec}") > 0) {{
-        if (!PyArg_ParseTuple(___arg, "{argspec}", {derefargumentnames})) {{
-            return NULL;
-        }}
-    }}
 #ifdef SINGLEARG
-    else {{
-        {singleargumentname} = ___arg;
+    {singleargumentname} = ___arg;
+#else 
+#ifndef NOARGS
+    if (!PyArg_ParseTuple(___arg, "{argspec}", {derefargumentnames})) {{
+        return NULL;
     }}
+#endif
 #endif
 
     return Py_BuildValue("{resultspec}", {callfunction}({argumentnames}));
@@ -326,10 +325,12 @@ def create_module(self, name=None):
 
         self._insert(fargs, "argumentdeclarations", ";".join(fargs["parseargs"]))
         self._insert(fargs, "argumentnames", ", ".join(arg.rpartition(" ")[2] for arg in fargs["arguments"]))
-        self._insert(fargs, "singleargumentname", fargs["arguments"][0].rpartition(" ")[2])
+        self._insert(fargs, "singleargumentname", fargs["arguments"][0].rpartition(" ")[2] if fargs["arguments"] else "")
         self._insert(fargs, "derefargumentnames", ", ".join("&" + arg.rpartition(" ")[2].partition("=")[0] for arg in fargs["arguments"]))
         self._insert(fargs, "callfunction", fargs["capifunction"])
-        if len(fargs["argspec"]) == 0:
+        if len(fargs["argspec"]) == 0 and len(fargs["arguments"]) == 0:
+            fargs["defines"] = "#define NOARGS"
+        elif len(fargs["argspec"]) == 0:
             fargs["defines"] = "#define SINGLEARG"
         else:
             fargs["defines"] = ""

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

@@ -39,13 +39,27 @@
 
 import sys
 from . import CPyExtTestCase, CPyExtFunction, CPyExtFunctionOutVars, unhandled_error_compare, GRAALPYTHON
+import builtins
 __dir__ = __file__.rpartition("/")[0]
 
+__global_builtins_dict = builtins.__dict__
+
 
 def _reference_importmodule(args):
     return __import__(args[0], fromlist=["*"])
 
 
+def _reference_format_float(args):
+    val, format_spec, prec = args
+    if format_spec == b'r':
+        return repr(val)
+    return float(val).__format__("." + str(prec) + format_spec.decode())
+
+
+def _reference_builtins(args):
+    return type(__global_builtins_dict)
+
+
 class TestMisc(CPyExtTestCase):
 
     def compile_module(self, name):
@@ -212,3 +226,42 @@ def compile_module(self, name):
         arguments=["PyObject* pyVal", "PyObject* fun"],
         cmpfunc=unhandled_error_compare
     )
+
+    test_PyOS_double_to_string = CPyExtFunction(
+        _reference_format_float,
+        lambda: (
+            (1.2, b"f", 2),
+            (float('nan'), b"f", 2),
+            (1.23456789, b"f", 2),
+            (123.456789, b"f", 6),
+            (123.456789, b"e", 6),
+            (123.456789, b"r", 0),
+        ),
+        code="""
+        char* wrap_PyOS_double_to_string(double val, char format, int prec) {
+            return PyOS_double_to_string(val, format, prec, 0, NULL);
+        }
+        """,
+        resultspec="s",
+        argspec="dci",
+        arguments=["double val", "char format", "int prec"],
+        callfunction="wrap_PyOS_double_to_string",
+        cmpfunc=unhandled_error_compare
+    )
+
+    test_PyEval_GetBuiltins = CPyExtFunction(
+        _reference_builtins,
+        lambda: (
+            tuple(),
+        ),
+        code="""
+        PyObject* wrap_PyEval_GetBuiltins() {
+            return Py_TYPE(PyEval_GetBuiltins());
+        }
+        """,
+        resultspec="O",
+        argspec="",
+        arguments=[],
+        callfunction="wrap_PyEval_GetBuiltins",
+        cmpfunc=unhandled_error_compare
+    )

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

@@ -185,6 +185,34 @@ def test_setitem():
         pass
 
 
+class BaseGetSlice:
+    def assertEqualWithType(self, a, b):
+        self.assertEqual(a, b)
+        self.assertEqual(type(a), type(b))
+
+    def test_getslice(self):
+        # whole sequence
+        b = self.type2test(b"hello")
+        self.assertEqualWithType(b[:], self.type2test(b"hello"))
+
+        # whole same length as slice
+        b = self.type2test(b"hellohellohello")
+        self.assertEqualWithType(b[5:10], self.type2test(b"hello"))
+
+        # shrink
+        b = self.type2test(b"hellohellohello")
+        self.assertEqualWithType(b[:10], self.type2test(b"hellohello"))
+
+        # extend
+        b = self.type2test(b"hellohelloworld")
+        self.assertEqualWithType(b[5:], self.type2test(b"helloworld"))
+
+class BytesGetSliceTest(BaseGetSlice, unittest.TestCase):
+    type2test = bytes
+
+class ByteArrayGetSliceTest(BaseGetSlice, unittest.TestCase):
+    type2test = bytearray
+
 def test_setslice():
     # whole sequence
     b = bytearray(b"hello")
@@ -646,6 +674,7 @@ def test_add_mv_to_bytes():
     mv = memoryview(b'world')
     b += mv
     assert b == b'hello world'
+    assert type(b) == bytes
 
 def test_add_mv_to_bytearray():
     ba = bytearray(b'hello ')

graalpython/com.oracle.graal.python.test/src/tests/test_list.py

@@ -54,6 +54,18 @@ def test_basic(self):
         l[0] = "hello"
         self.assertEqual(l, ["hello", 1, 2, 3, 4])
 
+    def test_literal(self):
+        self.assertEqual([1,2,3], [*[1,2,3]])
+        self.assertEqual([1,2,3], [*(1,2,3)])
+        self.assertEqual([1,2,3,4,5,6], [*(1,2,3), *(4,5,6)])
+
+        # this will certainly create a list where the capacity of the storage is not exhausted, i.e., 'length < cap',
+        # and so the storage contains null elements
+        l = []
+        for c in "abcdefghijk":
+            l.append(c)
+        self.assertEqual(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k'], [*l])
+
     def test_truth(self):
         super().test_truth()
         self.assertTrue(not [])

graalpython/com.oracle.graal.python.test/src/tests/test_property.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 #
 # The Universal Permissive License (UPL), Version 1.0
@@ -72,6 +72,22 @@ def prop_x(self):
         del self._x
 
 
+class X(object):
+    @property
+    def prop_x(self):
+        return self._prop_x
+
+    @prop_x.setter
+    def prop_x(self, new_val):
+        self._prop_x = new_val
+        return new_val
+
+class Y(X):
+    @X.prop_x.setter
+    def prop_x(self, ax):
+        X.prop_x.fset(self, ax)
+
+
 def test_properties():
     c = C(10)
     assert c.prop_x == 10
@@ -96,3 +112,5 @@ def test_properties():
     except AttributeError:
         not_found = True
     assert not_found
+
+    assert X.prop_x is not Y.prop_x

graalpython/com.oracle.graal.python.test/src/tests/test_set.py

@@ -187,13 +187,23 @@ def test_sub_and_super():
         assert not set('cbs').issuperset('a')
 
 
-def test_superset_list():
-    set = {1, 2, 3, 4}
-    list = [1, 2, 3, 4]
-    visited= False
-    if set.issuperset(list):
-        visited = True
-    assert visited
+def test_superset_subset():
+    l = [1, 2, 3, 4]
+    s = set(l)
+    t = tuple(l)
+    assert s.issuperset(s)
+    assert s.issuperset(l)
+    assert s.issuperset(t)
+    assert s >= s
+    assert_raises(TypeError, lambda: s >= l)
+    assert_raises(TypeError, lambda: s >= t)
+
+    assert s.issubset(s)
+    assert s.issubset(l)
+    assert s.issubset(t)
+    assert s <= s
+    assert_raises(TypeError, lambda: s <= l)
+    assert_raises(TypeError, lambda: s <= t)
 
 
 def test_intersection():
@@ -293,3 +303,13 @@ def test_set_delete():
     assert s == {'a', 'b', 'c'}
     s.discard('c')
     assert s == {'a', 'b'}
+
+
+def test_literal():
+    d = {"a": 1, "b": 2, "c": 3}
+    e = {"uff": "foo"}
+    assert {*d, *e} == {"a", "b", "c", "uff"}
+
+    d = {}
+    assert {*d} == set()
+

graalpython/com.oracle.graal.python.test/src/tests/test_tuple.py

@@ -22,6 +22,9 @@ def test_constructors(self):
         self.assertEqual(tuple(''), ())
         self.assertEqual(tuple('spam'), ('s', 'p', 'a', 'm'))
 
+    def test_literal(self):
+        self.assertEqual((1,2,3), (*[1,2,3],))
+
     def test_truth(self):
         super().test_truth()
         self.assertTrue(not ())