Merge pull request RustPython#3682 from youknowone/extra-test

Rename extra-tests with unified prefix form

Author: youknowone

.github/workflows/ci.yaml

@@ -352,6 +352,6 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --release --target wasm32-wasi --features freeze-stdlib --verbose
+          args: --release --target wasm32-wasi --features freeze-stdlib,stdlib --verbose
       - name: run snippets
-        run: wasmer run --dir . target/wasm32-wasi/release/rustpython.wasm -- extra_tests/snippets/variables.py
+        run: wasmer run --dir . target/wasm32-wasi/release/rustpython.wasm -- extra_tests/snippets/stdlib_random.py

extra_tests/snippets/basic_types.py

@@ -1,3 +1,4 @@
+import testutils
 from testutils import assert_raises
 
 # __abs__
@@ -209,3 +210,18 @@ def __eq__(self, other):
 assert complex('1e-500') == 0.0 + 0.0j
 assert complex('-1e-500j') == 0.0 - 0.0j
 assert complex('-1e-500+1e-500j') == -0.0 + 0.0j
+
+
+# __complex__
+def test__complex__():
+    z = 3 + 4j
+    assert z.__complex__() == z
+    assert type(z.__complex__()) == complex
+    
+    class complex_subclass(complex):
+        pass
+    z = complex_subclass(3 + 4j)
+    assert z.__complex__() == 3 + 4j
+    assert type(z.__complex__()) == complex
+
+testutils.skip_if_unsupported(3, 11, test__complex__)

extra_tests/snippets/bools.py extra_tests/snippets/builtin_bool.pyextra_tests/snippets/bools.py renamed to extra_tests/snippets/builtin_bool.py

@@ -61,4 +61,273 @@
 assert d1.keys().isdisjoint(d2.keys())
 d2 = {"b": 2, "d": 4}
 assert not d1.items().isdisjoint(d2.items())
-assert not d1.keys().isdisjoint(d2.keys())
+assert not d1.keys().isdisjoint(d2.keys())
+
+
+assert dict(a=2, b=3) == {'a': 2, 'b': 3}
+assert dict({'a': 2, 'b': 3}, b=4) == {'a': 2, 'b': 4}
+assert dict([('a', 2), ('b', 3)]) == {'a': 2, 'b': 3}
+
+assert {} == {}
+assert not {'a': 2} == {}
+assert not {} == {'a': 2}
+assert not {'b': 2} == {'a': 2}
+assert not {'a': 4} == {'a': 2}
+assert {'a': 2} == {'a': 2}
+
+nan = float('nan')
+assert {'a': nan} == {'a': nan}
+
+a = {'g': 5}
+b = {'a': a, 'd': 9}
+c = dict(b)
+c['d'] = 3
+c['a']['g'] = 2
+assert a == {'g': 2}
+assert b == {'a': a, 'd': 9}
+
+a.clear()
+assert len(a) == 0
+
+a = {'a': 5, 'b': 6}
+res = set()
+for value in a.values():
+        res.add(value)
+assert res == set([5,6])
+
+count = 0
+for (key, value) in a.items():
+        assert a[key] == value
+        count += 1
+assert count == len(a)
+
+res = set()
+for key in a.keys():
+        res.add(key)
+assert res == set(['a','b'])
+
+# Deleted values are correctly skipped over:
+x = {'a': 1, 'b': 2, 'c': 3, 'd': 3}
+del x['c']
+it = iter(x.items())
+assert ('a', 1) == next(it)
+assert ('b', 2) == next(it)
+assert ('d', 3) == next(it)
+with assert_raises(StopIteration):
+    next(it)
+
+with assert_raises(KeyError) as cm:
+    del x[10]
+assert cm.exception.args[0] == 10
+
+# Iterating a dictionary is just its keys:
+assert ['a', 'b', 'd'] == list(x)
+
+# Iterating view captures dictionary when iterated.
+data = {1: 2, 3: 4}
+items = data.items()
+assert list(items) == [(1, 2), (3, 4)]
+data[5] = 6
+assert list(items) == [(1, 2), (3, 4), (5, 6)]
+
+# Values can be changed during iteration.
+data = {1: 2, 3: 4}
+items = iter(data.items())
+assert (1, 2) == next(items)
+data[3] = "changed"
+assert (3, "changed") == next(items)
+
+# But we can't add or delete items during iteration.
+d = {}
+a = iter(d.items())
+d['a'] = 2
+b = iter(d.items())
+assert ('a', 2) == next(b)
+with assert_raises(RuntimeError):
+    next(a)
+del d['a']
+with assert_raises(RuntimeError):
+    next(b)
+
+# View isn't itself an iterator.
+with assert_raises(TypeError):
+    next(data.keys())
+
+assert len(data.keys()) == 2
+
+x = {}
+x[1] = 1
+assert x[1] == 1
+
+x[7] = 7
+x[2] = 2
+x[(5, 6)] = 5
+
+with assert_raises(TypeError):
+    x[[]] # Unhashable type.
+
+x["here"] = "here"
+assert x.get("not here", "default") == "default"
+assert x.get("here", "default") == "here"
+assert x.get("not here") == None
+
+class LengthDict(dict):
+    def __getitem__(self, k):
+        return len(k)
+
+x = LengthDict()
+assert type(x) == LengthDict
+assert x['word'] == 4
+assert x.get('word') is None
+
+assert 5 == eval("a + word", LengthDict())
+
+
+class Squares(dict):
+    def __missing__(self, k):
+        v = k * k
+        self[k] = v
+        return v
+
+x = Squares()
+assert x[-5] == 25
+
+# An object that hashes to the same value always, and compares equal if any its values match.
+class Hashable(object):
+    def __init__(self, *args):
+        self.values = args
+    def __hash__(self):
+        return 1
+    def __eq__(self, other):
+        for x in self.values:
+            for y in other.values:
+                if x == y:
+                    return True
+        return False
+
+x = {}
+x[Hashable(1,2)] = 8
+
+assert x[Hashable(1,2)] == 8
+assert x[Hashable(3,1)] == 8
+
+x[Hashable(8)] = 19
+x[Hashable(19,8)] = 1
+assert x[Hashable(8)] == 1
+assert len(x) == 2
+
+assert list({'a': 2, 'b': 10}) == ['a', 'b']
+x = {}
+x['a'] = 2
+x['b'] = 10
+assert list(x) == ['a', 'b']
+
+y = x.copy()
+x['c'] = 12
+assert y == {'a': 2, 'b': 10}
+
+y.update({'c': 19, "d": -1, 'b': 12})
+assert y == {'a': 2, 'b': 12, 'c': 19, 'd': -1}
+
+y.update(y)
+assert y == {'a': 2, 'b': 12, 'c': 19, 'd': -1}  # hasn't changed
+
+# KeyError has object that used as key as an .args[0]
+with assert_raises(KeyError) as cm:
+    x['not here']
+assert cm.exception.args[0] == "not here"
+with assert_raises(KeyError) as cm:
+    x.pop('not here')
+assert cm.exception.args[0] == "not here"
+
+with assert_raises(KeyError) as cm:
+    x[10]
+assert cm.exception.args[0] == 10
+with assert_raises(KeyError) as cm:
+    x.pop(10)
+assert cm.exception.args[0] == 10
+
+class MyClass: pass
+obj = MyClass()
+
+with assert_raises(KeyError) as cm:
+    x[obj]
+assert cm.exception.args[0] == obj
+with assert_raises(KeyError) as cm:
+    x.pop(obj)
+assert cm.exception.args[0] == obj
+
+x = {1: 'a', '1': None}
+assert x.pop(1) == 'a'
+assert x.pop('1') is None
+assert x == {}
+
+x = {1: 'a'}
+assert (1, 'a') == x.popitem()
+assert x == {}
+with assert_raises(KeyError) as cm:
+    x.popitem()
+assert cm.exception.args == ('popitem(): dictionary is empty',)
+
+x = {'a': 4}
+assert 4 == x.setdefault('a', 0)
+assert x['a'] == 4
+assert 0 == x.setdefault('b', 0)
+assert x['b'] == 0
+assert None == x.setdefault('c')
+assert x['c'] is None
+
+assert {1: None, "b": None} == dict.fromkeys([1, "b"])
+assert {1: 0, "b": 0} == dict.fromkeys([1, "b"], 0)
+
+x = {'a': 1, 'b': 1, 'c': 1}
+y = {'b': 2, 'c': 2, 'd': 2}
+z = {'c': 3, 'd': 3, 'e': 3}
+
+w = {1: 1, **x, 2: 2, **y, 3: 3, **z, 4: 4}
+assert w == {1: 1, 'a': 1, 'b': 2, 'c': 3, 2: 2, 'd': 3, 3: 3, 'e': 3, 4: 4}
+
+assert str({True: True, 1.0: 1.0}) == str({True: 1.0})
+
+class A:
+    def __hash__(self):
+        return 1
+    def __eq__(self, other):
+        return isinstance(other, A)
+class B:
+    def __hash__(self):
+        return 1
+    def __eq__(self, other):
+        return isinstance(other, B)
+
+s = {1: 0, A(): 1, B(): 2}
+assert len(s) == 3
+assert s[1] == 0
+assert s[A()] == 1
+assert s[B()] == 2
+
+# Test dict usage in set with star expressions!
+a = {'bla': 2}
+b = {'c': 44, 'bla': 332, 'd': 6}
+x = ['bla', 'c', 'd', 'f']
+c = {*a, *b, *x}
+# print(c, type(c))
+assert isinstance(c, set)
+assert c == {'bla', 'c', 'd', 'f'}
+
+assert not {}.__ne__({})
+assert {}.__ne__({'a':'b'})
+assert {}.__ne__(1) == NotImplemented
+
+it = iter({0: 1, 2: 3, 4:5, 6:7})
+assert it.__length_hint__() == 4
+next(it)
+assert it.__length_hint__() == 3
+next(it)
+assert it.__length_hint__() == 2
+next(it)
+assert it.__length_hint__() == 1
+next(it)
+assert it.__length_hint__() == 0
+assert_raises(StopIteration, next, it)
+assert it.__length_hint__() == 0