fix

Author: youknowone

Lib/test/test_time.py

@@ -158,7 +158,6 @@ def test_conversions(self):
         self.assertEqual(int(time.mktime(time.localtime(self.t))),
                          int(self.t))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'integer or float' not found in 'expected an int or float for duration, got list'
     def test_sleep_exceptions(self):
         self.assertRaises(TypeError, time.sleep, [])
         self.assertRaises(TypeError, time.sleep, "a")
@@ -209,7 +208,6 @@ def test_strftime_invalid_format(self):
                     except ValueError as exc:
                         self.assertEqual(str(exc), 'Invalid format string')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; UnicodeEncodeError: 'utf-8' codec can't encode character '\ud83d' in position 0: surrogates not allowed
     def test_strftime_special(self):
         tt = time.gmtime(self.t)
         s1 = time.strftime('%c', tt)

crates/vm/src/stdlib/time.rs

@@ -27,7 +27,9 @@ unsafe extern "C" {
 mod decl {
     use crate::{
         AsObject, Py, PyObjectRef, PyResult, VirtualMachine,
-        builtins::{PyStrRef, PyTypeRef, PyUtf8StrRef},
+        builtins::{PyStrRef, PyTypeRef},
+        common::wtf8::Wtf8Buf,
+        convert::ToPyObject,
         function::{Either, FuncArgs, OptionalArg},
         types::{PyStructSequence, struct_sequence_new},
     };
@@ -85,13 +87,19 @@ mod decl {
 
     #[pyfunction]
     fn sleep(seconds: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let seconds_type_name = seconds.clone().class().name().to_owned();
         let dur = seconds.try_into_value::<Duration>(vm).map_err(|e| {
             if e.class().is(vm.ctx.exceptions.value_error)
                 && let Some(s) = e.args().first().and_then(|arg| arg.str(vm).ok())
                 && s.as_str() == "negative duration"
             {
                 return vm.new_value_error("sleep length must be non-negative");
             }
+            if e.class().is(vm.ctx.exceptions.type_error) {
+                return vm.new_type_error(format!(
+                    "'{seconds_type_name}' object cannot be interpreted as an integer or float"
+                ));
+            }
             e
         })?;
 
@@ -575,17 +583,9 @@ mod decl {
     }
 
     #[pyfunction]
-    fn strftime(
-        format: PyUtf8StrRef,
-        t: OptionalArg<StructTimeData>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
+    fn strftime(format: PyStrRef, t: OptionalArg<StructTimeData>, vm: &VirtualMachine) -> PyResult {
         #[cfg(unix)]
         {
-            if format.as_str().contains('\0') {
-                return Err(vm.new_value_error("embedded null character"));
-            }
-
             let checked_tm = match t {
                 OptionalArg::Present(value) => checked_tm_from_struct_time(&value, vm, "strftime")?,
                 OptionalArg::Missing => {
@@ -598,27 +598,60 @@ mod decl {
             let mut tm = checked_tm.tm;
             tm.tm_isdst = tm.tm_isdst.clamp(-1, 1);
 
-            let fmt = CString::new(format.as_str())
-                .map_err(|_| vm.new_value_error("embedded null character"))?;
-            let mut size = 1024usize;
-            let max_scale = 256usize.saturating_mul(format.as_str().len().max(1));
-
-            loop {
-                let mut out = vec![0u8; size];
-                let written = unsafe {
-                    libc::strftime(
-                        out.as_mut_ptr().cast(),
-                        out.len(),
-                        fmt.as_ptr(),
-                        &tm as *const libc::tm,
-                    )
-                };
-                if written > 0 || size >= max_scale {
-                    let s = String::from_utf8_lossy(&out[..written]).into_owned();
-                    return Ok(vm.ctx.new_str(s).into());
+            fn strftime_ascii(fmt: &str, tm: &libc::tm, vm: &VirtualMachine) -> PyResult<String> {
+                let fmt_c =
+                    CString::new(fmt).map_err(|_| vm.new_value_error("embedded null character"))?;
+                let mut size = 1024usize;
+                let max_scale = 256usize.saturating_mul(fmt.len().max(1));
+                loop {
+                    let mut out = vec![0u8; size];
+                    let written = unsafe {
+                        libc::strftime(
+                            out.as_mut_ptr().cast(),
+                            out.len(),
+                            fmt_c.as_ptr(),
+                            tm as *const libc::tm,
+                        )
+                    };
+                    if written > 0 || size >= max_scale {
+                        return Ok(String::from_utf8_lossy(&out[..written]).into_owned());
+                    }
+                    size = size.saturating_mul(2);
+                }
+            }
+
+            let mut out = Wtf8Buf::new();
+            let mut ascii = String::new();
+
+            for codepoint in format.as_wtf8().code_points() {
+                if codepoint.to_u32() == 0 {
+                    if !ascii.is_empty() {
+                        let part = strftime_ascii(&ascii, &tm, vm)?;
+                        out.extend(part.chars());
+                        ascii.clear();
+                    }
+                    out.push(codepoint);
+                    continue;
+                }
+                if let Some(ch) = codepoint.to_char()
+                    && ch.is_ascii()
+                {
+                    ascii.push(ch);
+                    continue;
                 }
-                size = size.saturating_mul(2);
+
+                if !ascii.is_empty() {
+                    let part = strftime_ascii(&ascii, &tm, vm)?;
+                    out.extend(part.chars());
+                    ascii.clear();
+                }
+                out.push(codepoint);
+            }
+            if !ascii.is_empty() {
+                let part = strftime_ascii(&ascii, &tm, vm)?;
+                out.extend(part.chars());
             }
+            Ok(out.to_pyobject(vm))
         }
 
         #[cfg(not(unix))]