Merge branch 'master' of https://github.com/RustPython/RustPython

Author: Tom1380

Cargo.lock

@@ -0,0 +1,24 @@
+# __abs__
+
+assert abs(complex(3, 4)) == 5
+assert abs(complex(3, -4)) == 5
+assert abs(complex(1.5, 2.5)) == 2.9154759474226504
+
+# __eq__
+
+assert complex(1, -1) == complex(1, -1)
+assert complex(1, 0) == 1
+assert not complex(1, 1) == 1
+assert complex(1, 0) == 1.0
+assert not complex(1, 1) == 1.0
+assert not complex(1, 0) == 1.5
+assert bool(complex(1, 0))
+assert not complex(1, 2) == complex(1, 1)
+# Currently broken - see issue #419
+# assert complex(1, 2) != 'foo'
+assert complex(1, 2).__eq__('foo') == NotImplemented
+
+# __neg__
+
+assert -complex(1, -1) == complex(-1, 1)
+assert -complex(0, 0) == complex(0, 0)

tests/snippets/builtin_complex.py

@@ -4,3 +4,7 @@
 assert len({"a": "b"}) == 1
 assert len({"a": "b", "b": 1}) == 2
 assert len({"a": "b", "b": 1, "a" + "b": 2*2}) == 3
+
+d = {}
+d['a'] = d
+assert repr(d) == "{'a': {...}}"

tests/snippets/builtin_dict.py

@@ -39,6 +39,15 @@ def assert_raises(expr, exc_type):
 # index raises value error if needle is not an int
 assert_raises(lambda _: range(10).index('foo'), ValueError)
 
+# count tests
+assert range(10).count(2) == 1
+assert range(10).count(11) == 0
+assert range(10).count(-1) == 0
+assert range(9, 12).count(10) == 1
+assert range(4, 10, 2).count(4) == 1
+assert range(4, 10, 2).count(7) == 0
+assert range(10).count("foo") == 0
+
 # __bool__
 assert bool(range(1))
 assert bool(range(1, 2))
@@ -61,3 +70,4 @@ def assert_raises(expr, exc_type):
 # __reversed__
 assert list(reversed(range(5))) == [4, 3, 2, 1, 0]
 assert list(reversed(range(5, 0, -1))) == [1, 2, 3, 4, 5]
+assert list(reversed(range(1,10,5))) == [6, 1]

tests/snippets/builtin_range.py

@@ -18,3 +18,24 @@
 assert a + b == 2.5
 assert a - c == 0
 assert a / c == 1
+
+assert a < 5
+assert a <= 5
+try:
+    assert a < 'a'
+except TypeError:
+    pass
+try:
+    assert a <= 'a'
+except TypeError:
+    pass
+assert a > 1
+assert a >= 1
+try:
+    assert a > 'a'
+except TypeError:
+    pass
+try:
+    assert a >= 'a'
+except TypeError:
+    pass

tests/snippets/floats.py

@@ -0,0 +1,15 @@
+# 10**308 cannot be represented exactly in f64, thus it is not equal to 1e308 float
+assert not (10**308 == 1e308)
+# but the 1e308 float can be converted to big int and then it still should be equal to itself
+assert int(1e308) == 1e308
+
+# and the equalities should be the same when operands switch sides
+assert not (1e308 == 10**308)
+assert 1e308 == int(1e308)
+
+# floats that cannot be converted to big ints shouldn’t crash the vm
+import math
+assert not (10**500 == math.inf)
+assert not (math.inf == 10**500)
+assert not (10**500 == math.nan)
+assert not (math.nan == 10**500)

tests/snippets/int_float_equality.py

@@ -38,3 +38,7 @@
     pass
 else:
     assert False, "IndexError was not raised"
+
+recursive = []
+recursive.append(recursive)
+assert repr(recursive) == "[[...]]"

tests/snippets/list.py

@@ -13,6 +13,18 @@
 # TODO: uncomment this when bytes are implemented
 # assert b"foo" in b"foobar"
 # assert b"whatever" not in b"foobar"
+assert b"1" < b"2"
+assert b"1" <= b"2"
+assert b"5" <= b"5"
+assert b"4" > b"2"
+assert not b"1" >= b"2"
+assert b"10" >= b"10"
+try:
+    bytes() > 2
+except TypeError:
+    pass
+else:
+    assert False, "TypeError not raised"
 
 # test tuple
 assert 1 in (1, 2)

tests/snippets/math.py renamed to tests/snippets/math_basics.py

@@ -24,3 +24,19 @@
 assert set([1,2]) < set([1,2,3])
 assert not set([1,2]) < set([1,2])
 assert not set([1,3]) < set([1,2])
+
+
+class Hashable(object):
+    def __init__(self, obj):
+        self.obj = obj
+
+    def __repr__(self):
+        return repr(self.obj)
+
+    def __hash__(self):
+        return id(self)
+
+
+recursive = set()
+recursive.add(Hashable(recursive))
+assert repr(recursive) == "{set(...)}"

tests/snippets/membership.py

@@ -8,3 +8,8 @@
     assert False
 except FileNotFoundError:
     pass
+
+
+assert os.O_RDONLY == 0
+assert os.O_WRONLY == 1
+assert os.O_RDWR == 2

tests/snippets/os_static.py

@@ -78,3 +78,10 @@
 assert "{0} {1}".format(2,3) == "2 3"
 assert "--{:s>4}--".format(1) == "--sss1--"
 assert "{keyword} {0}".format(1, keyword=2) == "2 1"
+
+assert 'a' < 'b'
+assert 'a' <= 'b'
+assert 'a' <= 'a'
+assert 'z' > 'b'
+assert 'z' >= 'b'
+assert 'a' >= 'a'

tests/snippets/set.py

@@ -0,0 +1,20 @@
+
+empty_set = set()
+non_empty_set = set([1,2,3])
+set_from_literal = {1,2,3}
+
+assert 1 in non_empty_set
+assert 4 not in non_empty_set
+
+assert 1 in set_from_literal
+assert 4 not in set_from_literal
+
+# TODO: Assert that empty aruguments raises exception.
+non_empty_set.add('a')
+assert 'a' in non_empty_set
+
+# TODO: Assert that empty arguments, or item not in set raises exception.
+non_empty_set.remove(1)
+assert 1 not in non_empty_set
+
+# TODO: Assert that adding the same thing to a set once it's already there doesn't do anything.

tests/snippets/buffered_reader.py renamed to tests/snippets/stdlib_io.py

@@ -19,3 +19,8 @@
 
 b = (1,2,3)
 assert b.index(2) == 1
+
+recursive_list = []
+recursive = (recursive_list,)
+recursive_list.append(recursive)
+assert repr(recursive) == "([(...)],)"

tests/snippets/os_open.py renamed to tests/snippets/stdlib_os.py

@@ -20,3 +20,4 @@ regex = "1"
 statrs = "0.10.0"
 caseless = "0.2.1"
 unicode-segmentation = "1.2.1"
+lazy_static = "^1.0.1"

tests/snippets/strings.py

@@ -718,6 +718,9 @@ pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     ctx.set_attr(&py_mod, "type", ctx.type_type());
     ctx.set_attr(&py_mod, "zip", ctx.zip_type());
 
+    // Constants
+    ctx.set_attr(&py_mod, "NotImplemented", ctx.not_implemented.clone());
+
     // Exceptions:
     ctx.set_attr(
         &py_mod,

tests/snippets/test_sets.py

@@ -226,7 +226,10 @@ impl Frame {
             }
             bytecode::Instruction::BuildSet { size, unpack } => {
                 let elements = self.get_elements(vm, *size, *unpack)?;
-                let py_obj = vm.ctx.new_set(elements);
+                let py_obj = vm.ctx.new_set();
+                for item in elements {
+                    vm.call_method(&py_obj, "add", vec![item])?;
+                }
                 self.push_value(py_obj);
                 Ok(None)
             }
@@ -1085,7 +1088,7 @@ impl fmt::Debug for Frame {
         let stack_str = self
             .stack
             .iter()
-            .map(|elem| format!("\n  > {}", elem.borrow().str()))
+            .map(|elem| format!("\n  > {:?}", elem.borrow()))
             .collect::<Vec<_>>()
             .join("");
         let block_str = self
@@ -1099,9 +1102,7 @@ impl fmt::Debug for Frame {
                 PyObjectPayload::Dict { ref elements } => {
                     objdict::get_key_value_pairs_from_content(elements)
                         .iter()
-                        .map(|elem| {
-                            format!("\n  {} = {}", elem.0.borrow().str(), elem.1.borrow().str())
-                        })
+                        .map(|elem| format!("\n  {:?} = {:?}", elem.0.borrow(), elem.1.borrow()))
                         .collect::<Vec<_>>()
                         .join("")
                 }

tests/snippets/tuple.py

@@ -8,6 +8,8 @@
 #[macro_use]
 extern crate bitflags;
 #[macro_use]
+extern crate lazy_static;
+#[macro_use]
 extern crate log;
 // extern crate env_logger;
 extern crate num_bigint;

vm/Cargo.toml

@@ -27,6 +27,10 @@ pub fn init(context: &PyContext) {
          - an integer";
 
     context.set_attr(bytes_type, "__eq__", context.new_rustfunc(bytes_eq));
+    context.set_attr(bytes_type, "__lt__", context.new_rustfunc(bytes_lt));
+    context.set_attr(bytes_type, "__le__", context.new_rustfunc(bytes_le));
+    context.set_attr(bytes_type, "__gt__", context.new_rustfunc(bytes_gt));
+    context.set_attr(bytes_type, "__ge__", context.new_rustfunc(bytes_ge));
     context.set_attr(bytes_type, "__hash__", context.new_rustfunc(bytes_hash));
     context.set_attr(bytes_type, "__new__", context.new_rustfunc(bytes_new));
     context.set_attr(bytes_type, "__repr__", context.new_rustfunc(bytes_repr));
@@ -82,6 +86,82 @@ fn bytes_eq(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.ctx.new_bool(result))
 }
 
+fn bytes_ge(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(a, Some(vm.ctx.bytes_type())), (b, None)]
+    );
+
+    let result = if objtype::isinstance(b, &vm.ctx.bytes_type()) {
+        get_value(a).to_vec() >= get_value(b).to_vec()
+    } else {
+        return Err(vm.new_type_error(format!(
+            "Cannot compare {} and {} using '>'",
+            a.borrow(),
+            b.borrow()
+        )));
+    };
+    Ok(vm.ctx.new_bool(result))
+}
+
+fn bytes_gt(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(a, Some(vm.ctx.bytes_type())), (b, None)]
+    );
+
+    let result = if objtype::isinstance(b, &vm.ctx.bytes_type()) {
+        get_value(a).to_vec() > get_value(b).to_vec()
+    } else {
+        return Err(vm.new_type_error(format!(
+            "Cannot compare {} and {} using '>='",
+            a.borrow(),
+            b.borrow()
+        )));
+    };
+    Ok(vm.ctx.new_bool(result))
+}
+
+fn bytes_le(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(a, Some(vm.ctx.bytes_type())), (b, None)]
+    );
+
+    let result = if objtype::isinstance(b, &vm.ctx.bytes_type()) {
+        get_value(a).to_vec() <= get_value(b).to_vec()
+    } else {
+        return Err(vm.new_type_error(format!(
+            "Cannot compare {} and {} using '<'",
+            a.borrow(),
+            b.borrow()
+        )));
+    };
+    Ok(vm.ctx.new_bool(result))
+}
+
+fn bytes_lt(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(a, Some(vm.ctx.bytes_type())), (b, None)]
+    );
+
+    let result = if objtype::isinstance(b, &vm.ctx.bytes_type()) {
+        get_value(a).to_vec() < get_value(b).to_vec()
+    } else {
+        return Err(vm.new_type_error(format!(
+            "Cannot compare {} and {} using '<='",
+            a.borrow(),
+            b.borrow()
+        )));
+    };
+    Ok(vm.ctx.new_bool(result))
+}
+
 fn bytes_len(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(a, Some(vm.ctx.bytes_type()))]);