Merge pull request RustPython#2341 from carbotanium/test

coolreader18 · coolreader18 · commit 93ec5754237d · 2020-11-24T16:20:18.000-06:00
Change sum and round to take keywords
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
@@ -4,7 +4,7 @@
 import builtins
 import collections
 import decimal
-# import fractions XXX RustPython
+import fractions
 import io
 import locale
 import os
@@ -1200,8 +1200,6 @@ def test_repr(self):
         a[0] = a
         self.assertEqual(repr(a), '{0: {...}}')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_round(self):
         self.assertEqual(round(0.0), 0.0)
         self.assertEqual(type(round(0.0)), int)
@@ -1297,8 +1295,6 @@ def test_round_large(self):
         self.assertEqual(round(5e15+2), 5e15+2)
         self.assertEqual(round(5e15+3), 5e15+3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_bug_27936(self):
         # Verify that ndigits=None means the same as passing in no argument
         for x in [1234,
@@ -1316,8 +1312,6 @@ def test_setattr(self):
 
     # test_str(): see test_unicode.py and test_bytes.py for str() tests.
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_sum(self):
         self.assertEqual(sum([]), 0)
         self.assertEqual(sum(list(range(2,8))), 27)
diff --git a/vm/src/builtins/make_module.rs b/vm/src/builtins/make_module.rs
@@ -20,6 +20,7 @@ mod decl {
     use crate::builtins::pystr::{PyStr, PyStrRef};
     use crate::builtins::pytype::PyTypeRef;
     use crate::builtins::PyInt;
+    use crate::builtins::{PyByteArray, PyBytes};
     use crate::byteslike::PyBytesLike;
     use crate::common::{hash::PyHash, str::to_ascii};
     #[cfg(feature = "rustpython-compiler")]
@@ -707,21 +708,22 @@ mod decl {
         }
     }
 
-    #[pyfunction]
-    fn round(
+    #[derive(FromArgs)]
+    pub struct RoundArgs {
+        #[pyarg(any)]
         number: PyObjectRef,
-        ndigits: OptionalArg<Option<PyIntRef>>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let rounded = match ndigits {
-            OptionalArg::Present(ndigits) => match ndigits {
-                Some(int) => {
-                    let ndigits = vm.call_method(int.as_object(), "__int__", ())?;
-                    vm.call_method(&number, "__round__", (ndigits,))?
-                }
-                None => vm.call_method(&number, "__round__", ())?,
-            },
-            OptionalArg::Missing => {
+        #[pyarg(any, optional)]
+        ndigits: OptionalOption<PyObjectRef>,
+    }
+
+    #[pyfunction]
+    fn round(RoundArgs { number, ndigits }: RoundArgs, vm: &VirtualMachine) -> PyResult {
+        let rounded = match ndigits.flatten() {
+            Some(obj) => {
+                let ndigits = vm.to_index(&obj)?;
+                vm.call_method(&number, "__round__", (ndigits,))?
+            }
+            None => {
                 // without a parameter, the result type is coerced to int
                 vm.call_method(&number, "__round__", ())?
             }
@@ -750,10 +752,35 @@ mod decl {
         Ok(lst)
     }
 
+    #[derive(FromArgs)]
+    pub struct SumArgs {
+        #[pyarg(positional)]
+        iterable: PyIterable,
+        #[pyarg(any, optional)]
+        start: OptionalArg<PyObjectRef>,
+    }
+
     #[pyfunction]
-    fn sum(iterable: PyIterable, start: OptionalArg, vm: &VirtualMachine) -> PyResult {
+    fn sum(SumArgs { iterable, start }: SumArgs, vm: &VirtualMachine) -> PyResult {
         // Start with zero and add at will:
         let mut sum = start.into_option().unwrap_or_else(|| vm.ctx.new_int(0));
+
+        match_class!(match sum {
+            PyStr =>
+                return Err(vm.new_type_error(
+                    "sum() can't sum strings [use ''.join(seq) instead]".to_owned()
+                )),
+            PyBytes =>
+                return Err(vm.new_type_error(
+                    "sum() can't sum bytes [use b''.join(seq) instead]".to_owned()
+                )),
+            PyByteArray =>
+                return Err(vm.new_type_error(
+                    "sum() can't sum bytearray [use b''.join(seq) instead]".to_owned()
+                )),
+            _ => (),
+        });
+
         for item in iterable.iter(vm)? {
             sum = vm._add(&sum, &item?)?;
         }
