diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py
@@ -2013,7 +2013,6 @@ def __index__(self):
             self.assertEqual(instance.ba[0], ord("?"), "Assigned bytearray not altered")
             self.assertEqual(instance.new_ba, bytearray(0x180), "Wrong object altered")
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: unexpected type Evil
     def test_search_methods_reentrancy_raises_buffererror(self):
         # gh-142560: Raise BufferError if buffer mutates during search arg conversion.
         class Evil:
@@ -2063,7 +2062,6 @@ def __length_hint__(self):
 
         self.assertRaises(ValueError, float, bytearray())
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: BufferError not raised by hex
     def test_hex_use_after_free(self):
         # Prevent UAF in bytearray.hex(sep) with re-entrant sep.__len__.
         # Regression test for https://github.com/python/cpython/issues/143195.

diff --git a/Lib/test/test_enum.py b/Lib/test/test_enum.py
@@ -3036,7 +3036,6 @@ class ThirdFailedStrEnum(StrEnum):
                 one = '1'
                 two = b'2', 'ascii', 9
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; fails on encoding testing : TypeError: Expected type 'str' but 'builtin_function_or_method' found
     def test_custom_strenum(self):
         class CustomStrEnum(str, Enum):
             pass

diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py
@@ -275,7 +275,6 @@ def test_clinic_signature(self):
                     self._hashlib.new(digest_name, data=b'')
                     self._hashlib.new(digest_name, string=b'')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; duplicate positional/keyword arg error message differs
     @unittest.skipIf(get_fips_mode(), "skip in FIPS mode")
     def test_clinic_signature_errors(self):
         nomsg = b''

diff --git a/Lib/test/test_json/test_scanstring.py b/Lib/test/test_json/test_scanstring.py
@@ -144,7 +144,6 @@ def test_bad_escapes(self):
             with self.assertRaises(self.JSONDecodeError, msg=s):
                 scanstring(s, 1, True)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_overflow(self):
         with self.assertRaises(OverflowError):
             self.json.decoder.scanstring("xxx", sys.maxsize+1)

diff --git a/Lib/test/test_lzma.py b/Lib/test/test_lzma.py
@@ -63,7 +63,6 @@ def test_simple_bad_args(self):
         lzd.decompress(empty)
         self.assertRaises(EOFError, lzd.decompress, b"quux")
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; lzma.LZMAError: Failed to initialize encoder
     def test_bad_filter_spec(self):
         self.assertRaises(TypeError, LZMACompressor, filters=[b"wobsite"])
         self.assertRaises(ValueError, LZMACompressor, filters=[{"xyzzy": 3}])
@@ -674,7 +673,6 @@ def test_init_bad_preset(self):
         with self.assertRaises(ValueError):
             LZMAFile(BytesIO(COMPRESSED_XZ), preset=3)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; lzma.LZMAError: Failed to initialize encoder
     def test_init_bad_filter_spec(self):
         with self.assertRaises(TypeError):
             LZMAFile(BytesIO(), "w", filters=[b"wobsite"])

diff --git a/Lib/test/test_mmap.py b/Lib/test/test_mmap.py
@@ -924,7 +924,6 @@ def __index__(self):
         self.assertEqual(m.madvise(mmap.MADV_NORMAL, 0, Number()), None)
         self.assertEqual(m.madvise(mmap.MADV_NORMAL, 0, size), None)
 
-    @unittest.expectedFailureIf(sys.platform in ("linux", "win32"), "TODO: RUSTPYTHON")
     def test_resize_up_anonymous_mapping(self):
         """If the mmap is backed by the pagefile ensure a resize up can happen
         and that the original data is still in place

diff --git a/Lib/test/test_sqlite3/test_backup.py b/Lib/test/test_sqlite3/test_backup.py
@@ -103,7 +103,6 @@ def progress(status, remaining, total):
         self.assertEqual(len(journal), 1)
         self.assertEqual(journal[0], 0)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_non_callable_progress(self):
         with self.assertRaises(TypeError) as cm:
             with memory_database() as bck:

diff --git a/Lib/test/test_str.py b/Lib/test/test_str.py
@@ -2672,7 +2672,6 @@ def test_check_encoding_errors(self):
         proc = assert_python_failure('-X', 'dev', '-c', code)
         self.assertEqual(proc.rc, 10, proc)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "str expected at most 3 arguments, got 4" does not match "expected at most 3 arguments, got 4"
     def test_str_invalid_call(self):
         # too many args
         with self.assertRaisesRegex(TypeError, r"str expected at most 3 arguments, got 4"):

diff --git a/crates/stdlib/src/_sqlite3.rs b/crates/stdlib/src/_sqlite3.rs
@@ -397,7 +397,7 @@ mod _sqlite3 {
         #[pyarg(named, default = -1)]
         pages: c_int,
         #[pyarg(named, optional)]
-        progress: Option<ArgCallable>,
+        progress: Option<PyObjectRef>,
         #[pyarg(named, optional)]
         name: Option<PyStrRef>,
         #[pyarg(named, default = 0.250)]
@@ -1253,6 +1253,12 @@ mod _sqlite3 {
                 return Err(vm.new_value_error("target cannot be the same connection instance"));
             }
 
+            if let Some(progress) = &progress
+                && !progress.is_callable()
+            {
+                return Err(vm.new_type_error("progress argument must be a callable"));
+            }
+
             let pages = if pages == 0 { -1 } else { pages };
 
             let name_cstring;
@@ -1284,7 +1290,7 @@ mod _sqlite3 {
                 if let Some(progress) = &progress {
                     let remaining = unsafe { sqlite3_backup_remaining(handle) };
                     let pagecount = unsafe { sqlite3_backup_pagecount(handle) };
-                    if let Err(err) = progress.invoke((ret, remaining, pagecount), vm) {
+                    if let Err(err) = progress.call((ret, remaining, pagecount), vm) {
                         unsafe { sqlite3_backup_finish(handle) };
                         return Err(err);
                     }

diff --git a/crates/stdlib/src/blake2.rs b/crates/stdlib/src/blake2.rs
@@ -149,7 +149,7 @@ mod _blake2 {
 
         #[pyslot]
         fn slot_new(_cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            let args: BlakeHashArgs = args.bind(vm)?;
+            let args: BlakeHashArgs = args.bind_for(vm, "blake2b")?;
             Ok(Self {
                 inner: local_blake2b(args, vm)?,
             }
@@ -246,7 +246,7 @@ mod _blake2 {
 
         #[pyslot]
         fn slot_new(_cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            let args: BlakeHashArgs = args.bind(vm)?;
+            let args: BlakeHashArgs = args.bind_for(vm, "blake2s")?;
             Ok(Self {
                 inner: local_blake2s(args, vm)?,
             }

diff --git a/crates/stdlib/src/json.rs b/crates/stdlib/src/json.rs
@@ -1323,30 +1323,25 @@ mod _json {
     #[pyfunction]
     fn scanstring(
         s: PyStrRef,
-        end: usize,
+        end: isize,
         strict: OptionalArg<bool>,
         vm: &VirtualMachine,
     ) -> PyResult<(Wtf8Buf, usize)> {
         flame_guard!("_json::scanstring");
         let wtf8 = s.as_wtf8();
 
+        if end < 0 || end as usize > s.char_len() {
+            return Err(vm.new_value_error("end is out of bounds"));
+        }
+        let end = end as usize;
+
         // Convert char index `end` to byte index
         let byte_idx = if end == 0 {
             0
         } else {
             wtf8.code_point_indices()
                 .nth(end)
-                .map(|(i, _)| i)
-                .ok_or_else(|| {
-                    py_decode_error(
-                        json::DecodeError {
-                            msg: "Unterminated string starting at".to_owned(),
-                            pos: end - 1,
-                        },
-                        s.clone(),
-                        vm,
-                    )
-                })?
+                .map_or(wtf8.len(), |(i, _)| i)
         };
 
         let (result, end_char_idx, _bytes_consumed) =

diff --git a/crates/stdlib/src/lzma.rs b/crates/stdlib/src/lzma.rs
@@ -8,7 +8,7 @@ mod _lzma {
     use alloc::fmt;
     use core::sync::atomic::{AtomicBool, AtomicI32, Ordering};
     use rustpython_common::{compression::lzma as backend, lock::PyMutex};
-    use rustpython_vm::builtins::{PyBaseExceptionRef, PyBytes, PyDict, PyType, PyTypeRef};
+    use rustpython_vm::builtins::{PyBaseExceptionRef, PyBytes, PyDict, PyStr, PyType, PyTypeRef};
     use rustpython_vm::function::{ArgBytesLike, ItemDoc};
     use rustpython_vm::object::PyAtomicRef;
     use rustpython_vm::types::Constructor;
@@ -129,13 +129,54 @@ mod _lzma {
         })
     }
 
+    /// A key the filter does not take makes the whole specifier invalid, as
+    /// the spec dict is read as keyword arguments.
+    fn check_filter_spec_keys(
+        spec: &PyObject,
+        allowed: &[&str],
+        error: &str,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let dict = spec.downcast_ref::<PyDict>().ok_or_else(|| {
+            vm.new_type_error("Filter specifier must be a dict or dict-like object")
+        })?;
+        for key in dict.keys_vec() {
+            let ok = key.downcast_ref::<PyStr>().is_some_and(|k| {
+                allowed
+                    .iter()
+                    .any(|a| k.as_wtf8().as_bytes() == a.as_bytes())
+            });
+            if !ok {
+                return Err(vm.new_value_error(error.to_owned()));
+            }
+        }
+        Ok(())
+    }
+
     fn parse_filter_chain_item(
         spec: &PyObject,
         vm: &VirtualMachine,
     ) -> PyResult<backend::FilterSpec> {
         let mut parsed = filter_spec_with_id(spec, vm)?;
         match parsed.id {
             FILTER_LZMA1 | FILTER_LZMA2 => {
+                check_filter_spec_keys(
+                    spec,
+                    &[
+                        "id",
+                        "preset",
+                        "dict_size",
+                        "lc",
+                        "lp",
+                        "pb",
+                        "mode",
+                        "nice_len",
+                        "mf",
+                        "depth",
+                    ],
+                    "Invalid filter specifier for LZMA filter",
+                    vm,
+                )?;
                 parsed.preset = get_dict_opt_u32(spec, "preset", vm)?;
                 parsed.dict_size = get_dict_opt_u32(spec, "dict_size", vm)?;
                 parsed.lc = get_dict_opt_u32(spec, "lc", vm)?;
@@ -146,9 +187,23 @@ mod _lzma {
                 parsed.mf = get_dict_opt_u32(spec, "mf", vm)?;
                 parsed.depth = get_dict_opt_u32(spec, "depth", vm)?;
             }
-            FILTER_DELTA => parsed.dist = get_dict_opt_u32(spec, "dist", vm)?,
+            FILTER_DELTA => {
+                check_filter_spec_keys(
+                    spec,
+                    &["id", "dist"],
+                    "Invalid filter specifier for delta filter",
+                    vm,
+                )?;
+                parsed.dist = get_dict_opt_u32(spec, "dist", vm)?;
+            }
             FILTER_X86 | FILTER_POWERPC | FILTER_IA64 | FILTER_ARM | FILTER_ARMTHUMB
             | FILTER_SPARC => {
+                check_filter_spec_keys(
+                    spec,
+                    &["id", "start_offset"],
+                    "Invalid filter specifier for BCJ filter",
+                    vm,
+                )?;
                 parsed.start_offset = get_dict_opt_u32(spec, "start_offset", vm)?;
             }
             _ => {}

diff --git a/crates/stdlib/src/mmap.rs b/crates/stdlib/src/mmap.rs
@@ -188,6 +188,9 @@ mod mmap {
         mmap: PyMutex<Option<MmapObj>>,
         #[cfg(unix)]
         fd: AtomicCell<i32>,
+        // only read by the linux/netbsd mremap expansion check
+        #[cfg(any(target_os = "linux", target_os = "netbsd"))]
+        flags: core::ffi::c_int,
         #[cfg(windows)]
         handle: AtomicCell<isize>, // host_mmap::Handle is isize on Windows
         offset: i64,
@@ -402,7 +405,11 @@ mod mmap {
             }
 
             // TODO: memmap2 doesn't support mapping with prot and flags right now
-            let (_flags, _prot, access) = match access {
+            #[cfg_attr(
+                not(any(target_os = "linux", target_os = "netbsd")),
+                allow(unused_variables)
+            )]
+            let (flags, _prot, access) = match access {
                 AccessMode::Read => (MAP_SHARED, PROT_READ, access),
                 AccessMode::Write => (MAP_SHARED, PROT_READ | PROT_WRITE, access),
                 AccessMode::Copy => (MAP_PRIVATE, PROT_READ | PROT_WRITE, access),
@@ -476,6 +483,8 @@ mod mmap {
                 } else {
                     -1
                 }),
+                #[cfg(any(target_os = "linux", target_os = "netbsd"))]
+                flags,
                 offset,
                 size: AtomicCell::new(map_size),
                 pos: AtomicCell::new(0),
@@ -1041,9 +1050,26 @@ mod mmap {
 
         #[cfg(unix)]
         #[pymethod]
-        fn resize(zelf: &Py<Self>, _newsize: PyIntRef, vm: &VirtualMachine) -> PyResult<()> {
+        fn resize(zelf: &Py<Self>, newsize: PyIntRef, vm: &VirtualMachine) -> PyResult<()> {
             zelf.check_resizeable(vm)?;
+
+            let new_size: isize = newsize.try_to_primitive(vm).map_err(|_| {
+                vm.new_overflow_error("Python int too large to convert to C ssize_t")
+            })?;
+
+            // Linux mremap() refuses to grow a shared anonymous mapping, and NetBSD
+            // mremap() returns a mapping whose grown region is not backed.
+            #[cfg(any(target_os = "linux", target_os = "netbsd"))]
+            if zelf.fd.load() == -1
+                && zelf.flags & host_mmap::MAP_PRIVATE == 0
+                && new_size > zelf.size.load() as isize
+            {
+                return Err(vm.new_value_error("mmap: can't expand a shared anonymous mapping"));
+            }
+
             // TODO: implement using mremap on Linux
+            #[cfg(not(any(target_os = "linux", target_os = "netbsd")))]
+            let _ = new_size;
             Err(vm.new_system_error("mmap: resizing not available--no mremap()"))
         }