The any key/p39 string ops pr

Lib/test/string_tests.py

@@ -681,6 +681,45 @@ def test_replace_overflow(self):
         self.checkraises(OverflowError, A2_16, "replace", "A", A2_16)
         self.checkraises(OverflowError, A2_16, "replace", "AA", A2_16+A2_16)
 
+
+    # Python 3.9
+    def test_removeprefix(self):
+        self.checkequal('am', 'spam', 'removeprefix', 'sp')
+        self.checkequal('spamspam', 'spamspamspam', 'removeprefix', 'spam')
+        self.checkequal('spam', 'spam', 'removeprefix', 'python')
+        self.checkequal('spam', 'spam', 'removeprefix', 'spider')
+        self.checkequal('spam', 'spam', 'removeprefix', 'spam and eggs')
+
+        self.checkequal('', '', 'removeprefix', '')
+        self.checkequal('', '', 'removeprefix', 'abcde')
+        self.checkequal('abcde', 'abcde', 'removeprefix', '')
+        self.checkequal('', 'abcde', 'removeprefix', 'abcde')
+
+        self.checkraises(TypeError, 'hello', 'removeprefix')
+        self.checkraises(TypeError, 'hello', 'removeprefix', 42)
+        self.checkraises(TypeError, 'hello', 'removeprefix', 42, 'h')
+        self.checkraises(TypeError, 'hello', 'removeprefix', 'h', 42)
+        self.checkraises(TypeError, 'hello', 'removeprefix', ("he", "l"))
+
+    # Python 3.9
+    def test_removesuffix(self):
+        self.checkequal('sp', 'spam', 'removesuffix', 'am')
+        self.checkequal('spamspam', 'spamspamspam', 'removesuffix', 'spam')
+        self.checkequal('spam', 'spam', 'removesuffix', 'python')
+        self.checkequal('spam', 'spam', 'removesuffix', 'blam')
+        self.checkequal('spam', 'spam', 'removesuffix', 'eggs and spam')
+
+        self.checkequal('', '', 'removesuffix', '')
+        self.checkequal('', '', 'removesuffix', 'abcde')
+        self.checkequal('abcde', 'abcde', 'removesuffix', '')
+        self.checkequal('', 'abcde', 'removesuffix', 'abcde')
+
+        self.checkraises(TypeError, 'hello', 'removesuffix')
+        self.checkraises(TypeError, 'hello', 'removesuffix', 42)
+        self.checkraises(TypeError, 'hello', 'removesuffix', 42, 'h')
+        self.checkraises(TypeError, 'hello', 'removesuffix', 'h', 42)
+        self.checkraises(TypeError, 'hello', 'removesuffix', ("lo", "l"))
+
     def test_capitalize(self):
         self.checkequal(' hello ', ' hello ', 'capitalize')
         self.checkequal('Hello ', 'Hello ','capitalize')

Lib/test/test_array.py

@@ -341,8 +341,6 @@ def test_iterator_pickle(self):
             a.fromlist(data2)
             self.assertEqual(list(it), [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exhausted_iterator(self):
         a = array.array(self.typecode, self.example)
         self.assertEqual(list(a), list(self.example))

tests/snippets/dict_union.py

@@ -0,0 +1,83 @@
+
+import testutils
+
+def test_dunion_ior0():
+    a={1:2,2:3}
+    b={3:4,5:6}
+    a|=b
+
+    assert a == {1:2,2:3,3:4,5:6}, f"wrong value assigned {a=}"
+    assert b == {3:4,5:6}, f"right hand side modified, {b=}"
+
+def test_dunion_or0():
+    a={1:2,2:3}
+    b={3:4,5:6}
+    c=a|b
+
+    assert a == {1:2,2:3}, f"left hand side of non-assignment operator modified {a=}"
+    assert b == {3:4,5:6}, f"right hand side of non-assignment operator modified, {b=}"
+    assert c == {1:2,2:3, 3:4, 5:6}, f"unexpected result of dict union {c=}"
+
+
+def test_dunion_or1():
+    a={1:2,2:3}
+    b={3:4,5:6}
+    c=a.__or__(b)
+
+    assert a == {1:2,2:3}, f"left hand side of non-assignment operator modified {a=}"
+    assert b == {3:4,5:6}, f"right hand side of non-assignment operator modified, {b=}"
+    assert c == {1:2,2:3, 3:4, 5:6}, f"unexpected result of dict union {c=}"
+
+
+def test_dunion_ror0():
+    a={1:2,2:3}
+    b={3:4,5:6}
+    c=b.__ror__(a)
+
+    assert a == {1:2,2:3}, f"left hand side of non-assignment operator modified {a=}"
+    assert b == {3:4,5:6}, f"right hand side of non-assignment operator modified, {b=}"
+    assert c == {1:2,2:3, 3:4, 5:6}, f"unexpected result of dict union {c=}"
+
+
+def test_dunion_other_types():
+    def perf_test_or(other_obj):
+        d={1:2}
+        try:
+            d.__or__(other_obj)
+        except:
+            return True
+        return False
+
+    def perf_test_ior(other_obj):
+        d={1:2}
+        try:
+            d.__ior__(other_obj)
+        except:
+            return True
+        return False
+
+    def perf_test_ror(other_obj):
+        d={1:2}
+        try:
+            d.__ror__(other_obj)
+        except:
+            return True
+        return False
+
+    test_fct={'__or__':perf_test_or, '__ror__':perf_test_ror, '__ior__':perf_test_ior}
+    others=['FooBar', 42, [36], set([19]), ['aa'], None]
+    for tfn,tf in test_fct.items():
+        for other in others:
+            assert tf(other), f"Failed: dict {tfn}, accepted {other}"
+
+
+
+
+testutils.skip_if_unsupported(3,9,test_dunion_ior0)
+testutils.skip_if_unsupported(3,9,test_dunion_or0)
+testutils.skip_if_unsupported(3,9,test_dunion_or1)
+testutils.skip_if_unsupported(3,9,test_dunion_ror0)
+testutils.skip_if_unsupported(3,9,test_dunion_other_types)
+
+
+

tests/snippets/strings.py

@@ -1,4 +1,4 @@
-from testutils import assert_raises, AssertRaises
+from testutils import assert_raises, AssertRaises, skip_if_unsupported
 
 assert "".__eq__(1) == NotImplemented
 assert "a" == 'a'
@@ -471,3 +471,98 @@ def try_mutate_str():
 assert '{:e}'.format(float('inf')) == 'inf'
 assert '{:e}'.format(float('-inf')) == '-inf'
 assert '{:E}'.format(float('inf')) == 'INF'
+
+
+# remove*fix test
+def test_removeprefix():
+    s = 'foobarfoo'
+    s_ref='foobarfoo'
+    assert s.removeprefix('f') == s_ref[1:]
+    assert s.removeprefix('fo') == s_ref[2:]
+    assert s.removeprefix('foo') == s_ref[3:]
+
+    assert s.removeprefix('') == s_ref
+    assert s.removeprefix('bar') == s_ref
+    assert s.removeprefix('lol') == s_ref
+    assert s.removeprefix('_foo') == s_ref
+    assert s.removeprefix('-foo') == s_ref
+    assert s.removeprefix('afoo') == s_ref
+    assert s.removeprefix('*foo') == s_ref
+
+    assert s==s_ref, 'undefined test fail'
+
+    s_uc = '😱foobarfoo🖖'
+    s_ref_uc = '😱foobarfoo🖖'
+    assert s_uc.removeprefix('😱') == s_ref_uc[1:]
+    assert s_uc.removeprefix('😱fo') == s_ref_uc[3:]
+    assert s_uc.removeprefix('😱foo') == s_ref_uc[4:]
+
+    assert s_uc.removeprefix('🖖') == s_ref_uc
+    assert s_uc.removeprefix('foo') == s_ref_uc
+    assert s_uc.removeprefix(' ') == s_ref_uc
+    assert s_uc.removeprefix('_😱') == s_ref_uc
+    assert s_uc.removeprefix(' 😱') == s_ref_uc
+    assert s_uc.removeprefix('-😱') == s_ref_uc
+    assert s_uc.removeprefix('#😱') == s_ref_uc
+
+def test_removeprefix_types():
+    s='0123456'
+    s_ref='0123456'
+    others=[0,['012']]
+    found=False
+    for o in others:
+        try:
+            s.removeprefix(o)
+        except:
+            found=True
+
+        assert found, f'Removeprefix accepts other type: {type(o)}: {o=}'
+
+def test_removesuffix():
+    s='foobarfoo'
+    s_ref='foobarfoo'
+    assert s.removesuffix('o') == s_ref[:-1]
+    assert s.removesuffix('oo') == s_ref[:-2]
+    assert s.removesuffix('foo') == s_ref[:-3]
+
+    assert s.removesuffix('') == s_ref
+    assert s.removesuffix('bar') == s_ref
+    assert s.removesuffix('lol') == s_ref
+    assert s.removesuffix('foo_') == s_ref
+    assert s.removesuffix('foo-') == s_ref
+    assert s.removesuffix('foo*') == s_ref
+    assert s.removesuffix('fooa') == s_ref
+
+    assert s==s_ref, 'undefined test fail'
+
+    s_uc = '😱foobarfoo🖖'
+    s_ref_uc = '😱foobarfoo🖖'
+    assert s_uc.removesuffix('🖖') == s_ref_uc[:-1]
+    assert s_uc.removesuffix('oo🖖') == s_ref_uc[:-3]
+    assert s_uc.removesuffix('foo🖖') == s_ref_uc[:-4]
+
+    assert s_uc.removesuffix('😱') == s_ref_uc
+    assert s_uc.removesuffix('foo') == s_ref_uc
+    assert s_uc.removesuffix(' ') == s_ref_uc
+    assert s_uc.removesuffix('🖖_') == s_ref_uc
+    assert s_uc.removesuffix('🖖 ') == s_ref_uc
+    assert s_uc.removesuffix('🖖-') == s_ref_uc
+    assert s_uc.removesuffix('🖖#') == s_ref_uc
+
+def test_removesuffix_types():
+    s='0123456'
+    s_ref='0123456'
+    others=[0,6,['6']]
+    found=False
+    for o in others:
+        try:
+            s.removesuffix(o)
+        except:
+            found=True
+
+        assert found, f'Removesuffix accepts other type: {type(o)}: {o=}'
+
+skip_if_unsupported(3,9,test_removeprefix)
+skip_if_unsupported(3,9,test_removeprefix_types)
+skip_if_unsupported(3,9,test_removesuffix)
+skip_if_unsupported(3,9,test_removesuffix_types)

tests/snippets/testutils.py

@@ -1,3 +1,6 @@
+import platform
+import sys
+
 def assert_raises(expected, *args, _msg=None, **kw):
     if args:
         f, f_args = args[0], args[1:]
@@ -67,3 +70,25 @@ def assert_isinstance(obj, klass):
 
 def assert_in(a, b):
     _assert_print(lambda: a in b, [a, 'in', b])
+
+def skip_if_unsupported(req_maj_vers, req_min_vers, test_fct):
+    def exec():
+        test_fct()
+
+    if platform.python_implementation() == 'RustPython':
+        exec()
+    elif sys.version_info.major>=req_maj_vers and sys.version_info.minor>=req_min_vers:
+        exec()
+    else:
+        print(f'Skipping test as a higher python version is required. Using {platform.python_implementation()} {platform.python_version()}')
+
+def fail_if_unsupported(req_maj_vers, req_min_vers, test_fct):
+    def exec():
+        test_fct()
+
+    if platform.python_implementation() == 'RustPython':
+        exec()
+    elif sys.version_info.major>=req_maj_vers and sys.version_info.minor>=req_min_vers:
+        exec()
+    else:
+        assert False, f'Test cannot performed on this python version. {platform.python_implementation()} {platform.python_version()}'

tests/snippets/tuple.py

@@ -44,7 +44,7 @@ def __eq__(self, x):
 b = (55, *a)
 assert b == (55, 1, 2, 3, 1)
 
-assert () is ()
+assert () is ()  # noqa
 
 a = ()
 b = ()

vm/src/obj/objbytearray.rs

@@ -389,6 +389,30 @@ impl PyByteArray {
         self.borrow_value().rstrip(chars).into()
     }
 
+    /// removeprefix($self, prefix, /)
+    ///
+    ///
+    /// Return a bytearray object with the given prefix string removed if present.
+    ///
+    /// If the bytearray starts with the prefix string, return string[len(prefix):]
+    /// Otherwise, return a copy of the original bytearray.
+    #[pymethod(name = "removeprefix")]
+    fn removeprefix(&self, prefix: PyByteInner) -> PyByteArray {
+        self.borrow_value().removeprefix(prefix).into()
+    }
+
+    /// removesuffix(self, prefix, /)
+    ///
+    ///
+    /// Return a bytearray object with the given suffix string removed if present.
+    ///
+    /// If the bytearray ends with the suffix string, return string[:len(suffix)]
+    /// Otherwise, return a copy of the original bytearray.
+    #[pymethod(name = "removesuffix")]
+    fn removesuffix(&self, suffix: PyByteInner) -> PyByteArray {
+        self.borrow_value().removesuffix(suffix).to_vec().into()
+    }
+
     #[pymethod(name = "split")]
     fn split(&self, options: ByteInnerSplitOptions, vm: &VirtualMachine) -> PyResult {
         self.borrow_value()

vm/src/obj/objbyteinner.rs

@@ -843,6 +843,24 @@ impl PyByteInner {
             .to_vec()
     }
 
+    // new in Python 3.9
+    pub fn removeprefix(&self, prefix: PyByteInner) -> Vec<u8> {
+        self.elements
+            .py_removeprefix(&prefix.elements, prefix.elements.len(), |s, p| {
+                s.starts_with(p)
+            })
+            .to_vec()
+    }
+
+    // new in Python 3.9
+    pub fn removesuffix(&self, suffix: PyByteInner) -> Vec<u8> {
+        self.elements
+            .py_removesuffix(&suffix.elements, suffix.elements.len(), |s, p| {
+                s.ends_with(p)
+            })
+            .to_vec()
+    }
+
     pub fn split<F>(
         &self,
         options: ByteInnerSplitOptions,

vm/src/obj/objbytes.rs

@@ -347,6 +347,30 @@ impl PyBytes {
         self.inner.rstrip(chars).into()
     }
 
+    /// removeprefix($self, prefix, /)
+    ///
+    ///
+    /// Return a bytes object with the given prefix string removed if present.
+    ///
+    /// If the bytes starts with the prefix string, return string[len(prefix):]
+    /// Otherwise, return a copy of the original bytes.
+    #[pymethod(name = "removeprefix")]
+    fn removeprefix(&self, prefix: PyByteInner) -> PyBytes {
+        self.inner.removeprefix(prefix).into()
+    }
+
+    /// removesuffix(self, prefix, /)
+    ///
+    ///
+    /// Return a bytes object with the given suffix string removed if present.
+    ///
+    /// If the bytes ends with the suffix string, return string[:len(suffix)]
+    /// Otherwise, return a copy of the original bytes.
+    #[pymethod(name = "removesuffix")]
+    fn removesuffix(&self, suffix: PyByteInner) -> PyBytes {
+        self.inner.removesuffix(suffix).into()
+    }
+
     #[pymethod(name = "split")]
     fn split(&self, options: ByteInnerSplitOptions, vm: &VirtualMachine) -> PyResult {
         self.inner