ports/nrf: Upmerging port with upstream master

24 files changed, 294 insertions, 9 deletions

diff --git a/tests/basics/bytes.py b/tests/basics/bytes.py
index d3da15c8e..1d97e6b16 100644
--- a/tests/basics/bytes.py
+++ b/tests/basics/bytes.py
@@ -8,6 +8,9 @@ print(b'\u1234')
 print(bytes())
 print(bytes(b'abc'))
 
+# make sure empty bytes is converted correctly
+print(str(bytes(), 'utf-8'))
+
 a = b"123"
 print(a)
 print(str(a))
diff --git a/tests/basics/class_inplace_op.py b/tests/basics/class_inplace_op.py
new file mode 100644
index 000000000..62aad8c7c
--- /dev/null
+++ b/tests/basics/class_inplace_op.py
@@ -0,0 +1,47 @@
+# Case 1: Immutable object (e.g. number-like)
+# __iadd__ should not be defined, will be emulated using __add__
+
+class A:
+
+    def __init__(self, v):
+        self.v = v
+
+    def __add__(self, o):
+        return A(self.v + o.v)
+
+    def __repr__(self):
+        return "A(%s)" % self.v
+
+a = A(5)
+b = a
+a += A(3)
+print(a)
+# Should be original a's value, i.e. A(5)
+print(b)
+
+# Case 2: Mutable object (e.g. list-like)
+# __iadd__ should be defined
+
+class L:
+
+    def __init__(self, v):
+        self.v = v
+
+    def __add__(self, o):
+        # Should not be caled in this test
+        print("L.__add__")
+        return L(self.v + o.v)
+
+    def __iadd__(self, o):
+        self.v += o.v
+        return self
+
+    def __repr__(self):
+        return "L(%s)" % self.v
+
+c = L([1, 2])
+d = c
+c += L([3, 4])
+print(c)
+# Should be updated c's value, i.e. L([1, 2, 3, 4])
+print(d)
diff --git a/tests/basics/class_new.py b/tests/basics/class_new.py
index 9a7072ad0..1f6a86c64 100644
--- a/tests/basics/class_new.py
+++ b/tests/basics/class_new.py
@@ -5,13 +5,14 @@ try:
 except AttributeError:
     print("SKIP")
     raise SystemExit
+
 class A:
     def __new__(cls):
         print("A.__new__")
         return super(cls, A).__new__(cls)
 
     def __init__(self):
-        pass
+        print("A.__init__")
 
     def meth(self):
         print('A.meth')
@@ -33,7 +34,33 @@ a.meth()
 a = a.__new__(A)
 a.meth()
 
+# __new__ returns not an instance of the class (None here), __init__
+# should not be called
+
 class B:
     def __new__(self, v1, v2):
-        None
-B(1, 2)
+        print("B.__new__", v1, v2)
+
+    def __init__(self, v1, v2):
+        # Should not be called in this test
+        print("B.__init__", v1, v2)
+
+print("B inst:", B(1, 2))
+
+
+# Variation of the above, __new__ returns an instance of another class,
+# __init__ should not be called
+
+class Dummy: pass
+
+class C:
+    def __new__(cls):
+        print("C.__new__")
+        return Dummy()
+
+    def __init__(self):
+        # Should not be called in this test
+        print("C.__init__")
+
+c = C()
+print(isinstance(c, Dummy))
diff --git a/tests/basics/class_notimpl.py b/tests/basics/class_notimpl.py
new file mode 100644
index 000000000..7fd8166f9
--- /dev/null
+++ b/tests/basics/class_notimpl.py
@@ -0,0 +1,50 @@
+# Test that returning of NotImplemented from binary op methods leads to
+# TypeError.
+try:
+    NotImplemented
+except NameError:
+    print("SKIP")
+    raise SystemExit
+
+class C:
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "C(%s)" % self.value
+
+    def __add__(self, rhs):
+        print(self, '+', rhs)
+        return NotImplemented
+
+    def __sub__(self, rhs):
+        print(self, '-', rhs)
+        return NotImplemented
+
+    def __lt__(self, rhs):
+        print(self, '<', rhs)
+        return NotImplemented
+
+    def __neg__(self):
+        print('-', self)
+        return NotImplemented
+
+c = C(0)
+
+try:
+    c + 1
+except TypeError:
+    print("TypeError")
+
+try:
+    c - 2
+except TypeError:
+    print("TypeError")
+
+try:
+    c < 1
+except TypeError:
+    print("TypeError")
+
+# NotImplemented isn't handled specially in unary methods
+print(-c)
diff --git a/tests/basics/class_reverse_op.py b/tests/basics/class_reverse_op.py
new file mode 100644
index 000000000..d41c55c9d
--- /dev/null
+++ b/tests/basics/class_reverse_op.py
@@ -0,0 +1,18 @@
+class A:
+
+    def __init__(self, v):
+        self.v = v
+
+    def __add__(self, o):
+        if isinstance(o, A):
+            return A(self.v + o.v)
+        return A(self.v + o)
+
+    def __radd__(self, o):
+        return A(self.v + o)
+
+    def __repr__(self):
+        return "A(%s)" % self.v
+
+print(A(3) + 1)
+print(2 + A(5))
diff --git a/tests/basics/containment.py b/tests/basics/containment.py
index bae366113..4c94a9bae 100644
--- a/tests/basics/containment.py
+++ b/tests/basics/containment.py
@@ -16,6 +16,17 @@ for needle in [haystack[:i+1] for i in range(len(haystack))]:
     print(haystack, "in", needle, "::", haystack in needle)
     print(haystack, "not in", needle, "::", haystack not in needle)
 
+# containment of bytes/ints in bytes
+print(b'' in b'123')
+print(b'0' in b'123', b'1' in b'123')
+print(48 in b'123', 49 in b'123')
+
+# containment of int in str is an error
+try:
+    1 in '123'
+except TypeError:
+    print('TypeError')
+
 # until here, the tests would work without the 'second attempt' iteration thing.
 
 for i in 1, 2:
diff --git a/tests/basics/list_compare.py b/tests/basics/list_compare.py
index eea881424..fd656c7f1 100644
--- a/tests/basics/list_compare.py
+++ b/tests/basics/list_compare.py
@@ -48,3 +48,13 @@ print([1] <= [1, 0])
 print([1] <= [1, -1])
 print([1, 0] <= [1])
 print([1, -1] <= [1])
+
+
+print([] == {})
+print([] != {})
+print([1] == (1,))
+
+try:
+    print([] < {})
+except TypeError:
+    print("TypeError")
diff --git a/tests/basics/object_new.py b/tests/basics/object_new.py
index a9c9482cb..1bf7bc0ec 100644
--- a/tests/basics/object_new.py
+++ b/tests/basics/object_new.py
@@ -12,6 +12,11 @@ except AttributeError:
 
 class Foo:
 
+    def __new__(cls):
+        # Should not be called in this test
+        print("in __new__")
+        raise RuntimeError
+
     def __init__(self):
         print("in __init__")
         self.attr = "something"
@@ -19,12 +24,13 @@ class Foo:
 
 o = object.__new__(Foo)
 #print(o)
-print(hasattr(o, "attr"))
-print(isinstance(o, Foo))
+print("Result of __new__ has .attr:", hasattr(o, "attr"))
+print("Result of __new__ is already a Foo:", isinstance(o, Foo))
+
 o.__init__()
 #print(dir(o))
-print(hasattr(o, "attr"))
-print(o.attr)
+print("After __init__ has .attr:", hasattr(o, "attr"))
+print(".attr:", o.attr)
 
 # should only be able to call __new__ on user types
 try:
diff --git a/tests/basics/set_binop.py b/tests/basics/set_binop.py
index 7848920b6..bc76533b1 100644
--- a/tests/basics/set_binop.py
+++ b/tests/basics/set_binop.py
@@ -47,6 +47,18 @@ s1 = s2 = set('abc')
 s1 -= set('ad')
 print(s1 is s2, len(s1))
 
+# RHS must be a set
+try:
+    print(set('12') >= '1')
+except TypeError:
+    print('TypeError')
+
+# RHS must be a set
+try:
+    print(set('12') <= '123')
+except TypeError:
+    print('TypeError')
+
 # unsupported operator
 try:
     set('abc') * 2
diff --git a/tests/basics/set_remove.py b/tests/basics/set_remove.py
index 5627516c4..072723911 100644
--- a/tests/basics/set_remove.py
+++ b/tests/basics/set_remove.py
@@ -4,8 +4,8 @@ print(s.remove(1))
 print(list(s))
 try:
     print(s.remove(1), "!!!")
-except KeyError:
-    pass
+except KeyError as er:
+    print('KeyError', er.args[0])
 else:
     print("failed to raise KeyError")
 
diff --git a/tests/basics/string_endswith.py b/tests/basics/string_endswith.py
index 3e8fba925..683562d10 100644
--- a/tests/basics/string_endswith.py
+++ b/tests/basics/string_endswith.py
@@ -10,3 +10,8 @@ print("foobar".endswith("foobarbaz"))
 #print("1foo".startswith("1foo", 1))
 #print("1fo".startswith("foo", 1))
 #print("1fo".startswith("foo", 10))
+
+try:
+    "foobar".endswith(1)
+except TypeError:
+    print("TypeError")
diff --git a/tests/basics/string_endswith_upy.py b/tests/basics/string_endswith_upy.py
new file mode 100644
index 000000000..06a4e71d2
--- /dev/null
+++ b/tests/basics/string_endswith_upy.py
@@ -0,0 +1,6 @@
+# MicroPython doesn't support tuple argument
+
+try:
+    "foobar".endswith(("bar", "sth"))
+except TypeError:
+    print("TypeError")
diff --git a/tests/basics/string_endswith_upy.py.exp b/tests/basics/string_endswith_upy.py.exp
new file mode 100644
index 000000000..6002b71c5
--- /dev/null
+++ b/tests/basics/string_endswith_upy.py.exp
@@ -0,0 +1 @@
+TypeError
diff --git a/tests/basics/string_startswith.py b/tests/basics/string_startswith.py
index 5cf730c03..e63ae3c18 100644
--- a/tests/basics/string_startswith.py
+++ b/tests/basics/string_startswith.py
@@ -9,3 +9,8 @@ print("1foo".startswith("foo", 1))
 print("1foo".startswith("1foo", 1))
 print("1fo".startswith("foo", 1))
 print("1fo".startswith("foo", 10))
+
+try:
+    "foobar".startswith(1)
+except TypeError:
+    print("TypeError")
diff --git a/tests/basics/string_startswith_upy.py b/tests/basics/string_startswith_upy.py
new file mode 100644
index 000000000..9ea1796c2
--- /dev/null
+++ b/tests/basics/string_startswith_upy.py
@@ -0,0 +1,6 @@
+# MicroPython doesn't support tuple argument
+
+try:
+    "foobar".startswith(("foo", "sth"))
+except TypeError:
+    print("TypeError")
diff --git a/tests/basics/string_startswith_upy.py.exp b/tests/basics/string_startswith_upy.py.exp
new file mode 100644
index 000000000..6002b71c5
--- /dev/null
+++ b/tests/basics/string_startswith_upy.py.exp
@@ -0,0 +1 @@
+TypeError
diff --git a/tests/basics/string_strip.py b/tests/basics/string_strip.py
index 5d99a78e5..971a4aae5 100644
--- a/tests/basics/string_strip.py
+++ b/tests/basics/string_strip.py
@@ -32,6 +32,13 @@ print("a ".strip())
 print("a ".lstrip())
 print("a ".rstrip())
 
+# \0 used to give a problem
+
+print("\0abc\0".strip())
+print("\0abc\0".lstrip())
+print("\0abc\0".rstrip())
+print("\0abc\0".strip("\0"))
+
 # Test that stripping unstrippable string returns original object
 s = "abc"
 print(id(s.strip()) == id(s))
diff --git a/tests/basics/struct1.py b/tests/basics/struct1.py
index a442beb1e..db34342a1 100644
--- a/tests/basics/struct1.py
+++ b/tests/basics/struct1.py
@@ -39,6 +39,12 @@ print(v == (10, 100, 200, 300))
 # network byte order
 print(struct.pack('!i', 123))
 
+# check that we get an error if the buffer is too small
+try:
+    struct.unpack('I', b'\x00\x00\x00')
+except:
+    print('struct.error')
+
 # first arg must be a string
 try:
     struct.pack(1, 2)
@@ -63,6 +69,12 @@ print(buf)
 struct.pack_into('<bbb', buf, -6, 0x44, 0x45, 0x46)
 print(buf)
 
+# check that we get an error if the buffer is too small
+try:
+    struct.pack_into('I', bytearray(1), 0, 0)
+except:
+    print('struct.error')
+
 try:
     struct.pack_into('<bbb', buf, 7, 0x41, 0x42, 0x43)
 except:
diff --git a/tests/basics/struct1_intbig.py b/tests/basics/struct1_intbig.py
index b1fec527e..380293f36 100644
--- a/tests/basics/struct1_intbig.py
+++ b/tests/basics/struct1_intbig.py
@@ -12,6 +12,8 @@ print(struct.pack("<I", 2**32 - 1))
 print(struct.pack("<I", 0xffffffff))
 
 # long long ints
+print(struct.pack("<Q", 1))
+print(struct.pack(">Q", 1))
 print(struct.pack("<Q", 2**64 - 1))
 print(struct.pack(">Q", 2**64 - 1))
 print(struct.pack("<Q", 0xffffffffffffffff))
diff --git a/tests/basics/struct2.py b/tests/basics/struct2.py
index d8234d0d3..ceb067776 100644
--- a/tests/basics/struct2.py
+++ b/tests/basics/struct2.py
@@ -25,6 +25,16 @@ print(struct.calcsize('0s1s0H2H'))
 print(struct.unpack('<0s1s0H2H', b'01234'))
 print(struct.pack('<0s1s0H2H', b'abc', b'abc', 258, 515))
 
+# check that we get an error if the buffer is too small
+try:
+    struct.unpack('2H', b'\x00\x00')
+except:
+    print('Exception')
+try:
+    struct.pack_into('2I', bytearray(4), 0, 0)
+except:
+    print('Exception')
+
 # check that unknown types raise an exception
 try:
     struct.unpack('z', b'1')
@@ -40,3 +50,30 @@ try:
     struct.calcsize('0z')
 except:
     print('Exception')
+
+# check that a count without a type specifier raises an exception
+
+try:
+    struct.calcsize('1')
+except:
+    print('Exception')
+
+try:
+    struct.pack('1')
+except:
+    print('Exception')
+
+try:
+    struct.pack_into('1', bytearray(4), 0, 'xx')
+except:
+    print('Exception')
+
+try:
+    struct.unpack('1', 'xx')
+except:
+    print('Exception')
+
+try:
+    struct.unpack_from('1', 'xx')
+except:
+    print('Exception')
diff --git a/tests/basics/struct_micropython.py b/tests/basics/struct_micropython.py
index 4b9dfe137..f203a4666 100644
--- a/tests/basics/struct_micropython.py
+++ b/tests/basics/struct_micropython.py
@@ -18,6 +18,9 @@ s = struct.pack("<O", o)
 o2 = struct.unpack("<O", s)
 print(o is o2[0])
 
+# pack can accept less arguments than required for the format spec
+print(struct.pack('<2I', 1))
+
 # pack and unpack pointer to a string
 # This requires uctypes to get the address of the string and instead of
 # putting this in a dedicated test that can be skipped we simply pass
diff --git a/tests/basics/struct_micropython.py.exp b/tests/basics/struct_micropython.py.exp
index 0ca95142b..55b7b6623 100644
--- a/tests/basics/struct_micropython.py.exp
+++ b/tests/basics/struct_micropython.py.exp
@@ -1 +1,2 @@
 True
+b'\x01\x00\x00\x00\x00\x00\x00\x00'
diff --git a/tests/basics/tuple_compare.py b/tests/basics/tuple_compare.py
index ad813f702..9558eb1db 100644
--- a/tests/basics/tuple_compare.py
+++ b/tests/basics/tuple_compare.py
@@ -53,3 +53,13 @@ print((10, 0) > (1, 1))
 print((10, 0) < (1, 1))
 print((0, 0, 10, 0) > (0, 0, 1, 1))
 print((0, 0, 10, 0) < (0, 0, 1, 1))
+
+
+print(() == {})
+print(() != {})
+print((1,) == [1])
+
+try:
+    print(() < {})
+except TypeError:
+    print("TypeError")
diff --git a/tests/basics/tuple_mult.py b/tests/basics/tuple_mult.py
index b128b2968..cac95185a 100644
--- a/tests/basics/tuple_mult.py
+++ b/tests/basics/tuple_mult.py
@@ -11,6 +11,11 @@ a = (1, 2, 3)
 c = a * 3
 print(a, c)
 
+# inplace multiplication
+a = (1, 2)
+a *= 2
+print(a)
+
 # unsupported type on RHS
 try:
     () * None