Merge remote-tracking branch 'origin/master' into tim/sklearn-linreg

Author: timfel

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

@@ -197,6 +197,10 @@ static PyObject* wrap_ssizeobjargproc(ssizeobjargproc f, PyObject* a, PyObject*
 	return PyLong_FromLong(f(explicit_cast(a), PyLong_AsSsize_t(size), explicit_cast(b)));
 }
 
+static PyObject* wrap_initproc(initproc f, PyObject* a, PyObject* b, PyObject* c) {
+	return PyLong_FromLong(f(explicit_cast(a), explicit_cast(b),  explicit_cast(c)));
+}
+
 /* very special case: operator '**' has an optional third arg */
 static PyObject* wrap_pow(ternaryfunc f, ...) {
     int nargs = polyglot_get_arg_count();
@@ -382,7 +386,7 @@ int PyType_Ready(PyTypeObject* cls) {
     ADD_SLOT("__next__", cls->tp_iternext, -1);
     ADD_SLOT("__get__", cls->tp_descr_get, -3);
     ADD_SLOT("__set__", cls->tp_descr_set, -3);
-    ADD_SLOT("__init__", cls->tp_init, METH_KEYWORDS | METH_VARARGS);
+    ADD_SLOT_CONV("__init__", wrap_initproc, cls->tp_init, METH_KEYWORDS | METH_VARARGS);
     ADD_SLOT_CONV("__alloc__", wrap_allocfunc, cls->tp_alloc, -2);
     ADD_SLOT("__new__", cls->tp_new, METH_KEYWORDS | METH_VARARGS);
     ADD_SLOT("__free__", cls->tp_free, -1);
@@ -613,7 +617,11 @@ int PyObject_Print(PyObject* object, FILE* fd, int flags) {
 }
 
 PyObject* PyObject_GetAttrString(PyObject* obj, const char* attr) {
-    return PyObject_GetAttr(obj, PyUnicode_FromString(attr));
+    void* result = polyglot_invoke(PY_TRUFFLE_CEXT, "PyObject_GetAttr", to_java(obj), polyglot_from_string(attr, "utf-8"));
+    if (result == ERROR_MARKER) {
+        return NULL;
+    }
+    return to_sulong(result);
 }
 
 int PyObject_SetAttrString(PyObject* obj, const char* attr, PyObject* value) {

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

@@ -74,6 +74,16 @@ PyObject* PyTruffle_Unicode_FromFormat(const char* fmt, int s, void* v0, void* v
     case 7: v7 = value; break;                  \
     case 8: v8 = value; break;                  \
     case 9: v9 = value; break;                  \
+    case 10: v10 = value; break;                \
+    case 11: v11 = value; break;                \
+    case 12: v12 = value; break;                \
+    case 13: v13 = value; break;                \
+    case 14: v14 = value; break;                \
+    case 15: v15 = value; break;                \
+    case 16: v16 = value; break;                \
+    case 17: v17 = value; break;                \
+    case 18: v18 = value; break;                \
+    case 19: v19 = value; break;                \
     }
 
     char* fmtcpy = strdup(fmt);

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

@@ -36,8 +36,9 @@
 # SOFTWARE.
 
 import sys
-import warnings
-from . import CPyExtTestCase, CPyExtFunction, CPyExtFunctionVoid, unhandled_error_compare, GRAALPYTHON
+
+from . import CPyExtTestCase, CPyExtFunction, unhandled_error_compare, GRAALPYTHON
+
 __dir__ = __file__.rpartition("/")[0]
 
 
@@ -326,7 +327,6 @@ def compile_module(self, name):
         cmpfunc=unhandled_error_compare
     )
 
-    # TODO enable once supported
     test_PyUnicode_GET_SIZE = CPyExtFunction(
         lambda args: len(args[0]),
         lambda: (

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

@@ -0,0 +1,60 @@
+# Copyright (c) 2018, Oracle and/or its affiliates.
+#
+# The Universal Permissive License (UPL), Version 1.0
+#
+# Subject to the condition set forth below, permission is hereby granted to any
+# person obtaining a copy of this software, associated documentation and/or data
+# (collectively the "Software"), free of charge and under any and all copyright
+# rights in the Software, and any and all patent rights owned or freely
+# licensable by each licensor hereunder covering either (i) the unmodified
+# Software as contributed to or provided by such licensor, or (ii) the Larger
+# Works (as defined below), to deal in both
+#
+# (a) the Software, and
+# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+#     one is included with the Software (each a "Larger Work" to which the
+#     Software is contributed by such licensors),
+#
+# without restriction, including without limitation the rights to copy, create
+# derivative works of, display, perform, and distribute the Software and make,
+# use, sell, offer for sale, import, export, have made, and have sold the
+# Software and the Larger Work(s), and to sublicense the foregoing rights on
+# either these or other terms.
+#
+# This license is subject to the following condition:
+#
+# The above copyright notice and either this complete permission notice or at a
+# minimum a reference to the UPL must be included in all copies or substantial
+# portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+def assert_raises(err, fn, *args, **kwargs):
+    raised = False
+    try:
+        fn(*args, **kwargs)
+    except err:
+        raised = True
+    assert raised
+
+
+def test_import():
+    imported = True
+    try:
+        import array
+    except ImportError:
+        imported = False
+    assert imported
+
+
+def test_create():
+    from array import array
+    a = array('b', b'x'*10)
+    assert str(a) == "array('b', [120, 120, 120, 120, 120, 120, 120, 120, 120, 120])"

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

@@ -347,3 +347,90 @@ def test_rfind():
     assert b"hello".rfind(b"x") == -1, "4"
     assert b"hello".rfind(b"ll") == 2, "3"
 
+
+def test_extend():
+    orig = b'hello'
+    a = bytearray(orig)
+    a.extend(a)
+
+    assert a == orig + orig
+    assert a[5:] == orig
+
+    a = bytearray(b'')
+    # Test iterators that don't have a __length_hint__
+    a.extend(map(int, orig * 25))
+    a.extend(int(x) for x in orig * 25)
+    assert a == orig * 50
+    assert a[-5:] == orig
+
+    a = bytearray(b'')
+    a.extend(iter(map(int, orig * 50)))
+    assert a == orig * 50
+    assert a[-5:] == orig
+
+    a = bytearray(b'')
+    a.extend(list(map(int, orig * 50)))
+    assert a == orig * 50
+    assert a[-5:] == orig
+
+    a = bytearray(b'')
+    assert_raises(ValueError, a.extend, [0, 1, 2, 256])
+    assert_raises(ValueError, a.extend, [0, 1, 2, -1])
+    assert len(a) == 0
+
+
+def test_startswith():
+    b = b'hello'
+    assert not b.startswith(b"anything")
+    assert b.startswith(b"hello")
+    assert b.startswith(b"hel")
+    assert b.startswith(b"h")
+    assert not b.startswith(b"hellow")
+    assert not b.startswith(b"ha")
+
+    b = bytearray(b'hello')
+    assert not b.startswith(b"anything")
+    assert b.startswith(b"hello")
+    assert b.startswith(b"hel")
+    assert b.startswith(b"h")
+    assert not b.startswith(b"hellow")
+    assert not b.startswith(b"ha")
+
+
+def test_endswith():
+    b = b'hello'
+    assert not b.endswith(b"anything")
+    assert b.endswith(b"hello")
+    assert b.endswith(b"llo")
+    assert b.endswith(b"o")
+    assert not b.endswith(b"whello")
+    assert not b.endswith(b"no")
+
+    b = bytearray(b'hello')
+    assert not b.endswith(b"anything")
+    assert b.endswith(b"hello")
+    assert b.endswith(b"llo")
+    assert b.endswith(b"o")
+    assert not b.endswith(b"whello")
+    assert not b.endswith(b"no")
+
+
+def test_find():
+    b = b'mississippi'
+    i = 105
+    w = 119
+
+    assert b.find(b'ss') == 2
+    assert b.find(b'w') == -1
+    assert b.find(b'mississippian') == -1
+
+    assert b.find(i) == 1
+    assert b.find(w) == -1
+
+    assert b.find(b'ss', 3) == 5
+    assert b.find(b'ss', 1, 7) == 2
+    assert b.find(b'ss', 1, 3) == -1
+
+    assert b.find(i, 6) == 7
+    assert b.find(i, 1, 3) == 1
+    assert b.find(w, 1, 3) == -1

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

@@ -2,6 +2,8 @@
 # Copyright (C) 1996-2017 Python Software Foundation
 #
 # Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+
+
 def assert_raises(err, fn, *args, **kwargs):
     raised = False
     try:
@@ -12,7 +14,12 @@ def assert_raises(err, fn, *args, **kwargs):
 
 
 def test_import():
-    import codecs
+    imported = True
+    try:
+        import codecs
+    except ImportError:
+        imported = False
+    assert imported
 
 
 def test_decode():
@@ -21,9 +28,9 @@ def test_decode():
     # TODO: this does not work yet due to the fact that we do not handle all strings literal types yet
     # assert codecs.decode(b'\xe4\xf6\xfc', 'latin-1') == '\xe4\xf6\xfc'
     # assert_raises(TypeError, codecs.decode)
-    # assert codecs.decode(b'abc') == 'abc'
+    assert codecs.decode(b'abc') == 'abc'
     # assert_raises(UnicodeDecodeError, codecs.decode, b'\xff', 'ascii')
-    #
+
     # test keywords
     # assert codecs.decode(obj=b'\xe4\xf6\xfc', encoding='latin-1') == '\xe4\xf6\xfc'
     # assert codecs.decode(b'[\xff]', 'ascii', errors='ignore') == '[]'
@@ -36,7 +43,7 @@ def test_encode():
     # TODO: this does not work yet due to the fact that we do not handle all strings literal types yet
     # assert codecs.encode('\xe4\xf6\xfc', 'latin-1') == b'\xe4\xf6\xfc'
     # assert_raises(TypeError, codecs.encode)
-    # assert_raises(LookupError, codecs.encode, "foo", "__spam__")
+    assert_raises(LookupError, codecs.encode, "foo", "__spam__")
     # assert codecs.encode('abc') == b'abc'
     # assert_raises(UnicodeEncodeError, codecs.encode, '\xffff', 'ascii')
 

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

@@ -45,8 +45,13 @@ def assert_raises(err, fn, *args, **kwargs):
 
 
 def test_import():
-    import collections
-    from collections import namedtuple, Counter, OrderedDict, _count_elements
-    from collections import UserDict, UserString, UserList
-    from collections import ChainMap
-    # from collections import deque
+    imported = True
+    try:
+        import collections
+        from collections import namedtuple, Counter, OrderedDict, _count_elements
+        from collections import UserDict, UserString, UserList
+        from collections import ChainMap
+        # from collections import deque
+    except ImportError:
+        imported = False
+    assert imported

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

@@ -575,3 +575,74 @@ def fromhex(cls, value1, value2):
         f = F.fromhex('1', '1')
         self.assertEqual(17.0, f)
         self.assertEqual(F, type(f))
+
+class MyFloat(float):
+    pass
+
+class RealImagConjugateTests(unittest.TestCase):
+    
+    def test_real_imag(self):
+        def builtinTest(number):
+            a = float(number)
+            b = a.real
+            c = a.imag
+            assert a == b
+            assert a is b
+            assert c == 0
+            assert type(a) == float
+            assert type(b) == float
+            assert type(c) == float
+
+        builtinTest(-9.1)
+        builtinTest(0.0)
+        builtinTest(9.2)
+        builtinTest(6227020800.90)
+        builtinTest(9999992432902008176640000999999.1)
+
+    def test_real_imag_subclass(self):
+        def subclassTest(number):
+            a = MyFloat(number)
+            b = a.real
+            c = a.imag
+            assert a == b
+            assert a is not b
+            assert c == 0.0
+            assert type(a) == MyFloat
+            assert type(b) == float
+            assert type(c) == float
+
+        subclassTest(-9.0)
+        subclassTest(0.0)
+        subclassTest(9.1)
+        subclassTest(6227020800.2)
+        subclassTest(9999992432902008176640000999999.33)
+
+    def test_conjugate(self):
+        def builtinTest(number):
+            a = float(number)
+            b = a.conjugate()
+            assert a == b
+            assert a is b
+            assert type(a) == float
+            assert type(b) == float
+
+        builtinTest(-9.1)
+        builtinTest(0.0)
+        builtinTest(9.2)
+        builtinTest(6227020800.90)
+        builtinTest(9999992432902008176640000999999.1)
+
+    def test_conjugate_subclass(self):
+        def subclassTest(number):
+            a = MyFloat(number)
+            b = a.conjugate()
+            assert a == b
+            assert a is not b
+            assert type(a) == MyFloat
+            assert type(b) == float
+
+        subclassTest(-9.0)
+        subclassTest(0.0)
+        subclassTest(9.1)
+        subclassTest(6227020800.2)
+        subclassTest(9999992432902008176640000999999.33)