rename extra_tests to prefix form

extra_tests/snippets/builtin_complex.py

@@ -1,3 +1,4 @@
+import testutils
 from testutils import assert_raises
 
 # __abs__
@@ -209,3 +210,18 @@ assert complex("( -j)") == -1j
 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/builtin_slice.py

@@ -1,51 +1,138 @@
 from testutils import assert_raises
 
+a = slice(10)
+assert a.start == None
+assert a.stop == 10
+assert a.step == None
+
+a = slice(0, 10, 1)
+assert a.start == 0
+assert a.stop == 10
+assert a.step == 1
+
+assert slice(10).__repr__() == 'slice(None, 10, None)'
+assert slice(None).__repr__() == 'slice(None, None, None)'
+assert slice(0, 10, 13).__repr__() == 'slice(0, 10, 13)'
+assert slice('0', 1.1, 2+3j).__repr__() == "slice('0', 1.1, (2+3j))"
+
+assert slice(10) == slice(10)
+assert slice(-1) != slice(1)
+assert slice(0, 10, 3) != slice(0, 11, 3)
+assert slice(0, None, 3) != slice(0, 'a', 3)
+assert slice(0, 'a', 3) == slice(0, 'a', 3)
+
+assert slice(0, 0, 0).__eq__(slice(0, 0, 0))
+assert not slice(0, 0, 1).__eq__(slice(0, 0, 0))
+assert not slice(0, 1, 0).__eq__(slice(0, 0, 0))
+assert not slice(1, 0, 0).__eq__(slice(0, 0, 0))
+assert slice(1, 0, 0).__ne__(slice(0, 0, 0))
+assert slice(0, 1, 0).__ne__(slice(0, 0, 0))
+assert slice(0, 0, 1).__ne__(slice(0, 0, 0))
+
+assert slice(0).__eq__(0) == NotImplemented
+assert slice(0).__ne__(0) == NotImplemented
+assert slice(None).__ne__(slice(0))
+
+# slice gt, ge, lt, le
+assert_raises(TypeError, lambda: slice(0, slice(), 0) < slice(0, 0, 0))
+assert_raises(TypeError, lambda: slice(0, slice(), 0) <= slice(0, 0, 0))
+assert_raises(TypeError, lambda: slice(0, slice(), 0) > slice(0, 0, 0))
+assert_raises(TypeError, lambda: slice(0, slice(), 0) >= slice(0, 0, 0))
+
+assert_raises(TypeError, lambda: slice(0, 0, 0) < slice(0, 0, slice()))
+assert_raises(TypeError, lambda: slice(0, 0, 0) <= slice(0, 0, slice()))
+assert_raises(TypeError, lambda: slice(0, 0, 0) > slice(0, 0, slice()))
+assert_raises(TypeError, lambda: slice(0, 0, 0) >= slice(0, 0, slice()))
+
+assert_raises(TypeError, lambda: slice(0, 0) >= slice(0, 0, 0))
+assert_raises(TypeError, lambda: slice(0, 0) <= slice(0, 0, 0))
+assert_raises(TypeError, lambda: slice(0, 0) < slice(0, 0, 0))
+assert_raises(TypeError, lambda: slice(0, 0) > slice(0, 0, 0))
+
+assert slice(0, 0, 0) < slice(0, 1, -1)
+assert slice(0, 0, 0) < slice(0, 0, 1)
+assert slice(0, 0, 0) > slice(0, 0, -1)
+assert slice(0, 0, 0) >= slice(0, 0, -1)
+assert not slice(0, 0, 0) <= slice(0, 0, -1)
+
+assert slice(0, 0, 0) > slice(0, -1, 1)
+assert slice(0, 0, 0) >= slice(0, -1, 1)
+assert slice(0, 0, 0) >= slice(0, -1, 1)
+
+assert slice(0, 0, 0) <= slice(0, 0, 1)
+assert slice(0, 0, 0) <= slice(0, 0, 0)
+assert slice(0, 0, 0) <= slice(0, 0, 0)
+assert not slice(0, 0, 0) > slice(0, 0, 0)
+assert not slice(0, 0, 0) < slice(0, 0, 0)
+
+assert not slice(0, float('nan'), float('nan')) <= slice(0, float('nan'), 1)
+assert not slice(0, float('nan'), float('nan')) <= slice(0, float('nan'), float('nan'))
+assert not slice(0, float('nan'), float('nan')) >= slice(0, float('nan'), float('nan'))
+assert not slice(0, float('nan'), float('nan')) < slice(0, float('nan'), float('nan'))
+assert not slice(0, float('nan'), float('nan')) > slice(0, float('nan'), float('nan'))
+
+assert slice(0, float('inf'), float('inf')) >= slice(0, float('inf'), 1)
+assert slice(0, float('inf'), float('inf')) <= slice(0, float('inf'), float('inf'))
+assert slice(0, float('inf'), float('inf')) >= slice(0, float('inf'), float('inf'))
+assert not slice(0, float('inf'), float('inf')) < slice(0, float('inf'), float('inf'))
+assert not slice(0, float('inf'), float('inf')) > slice(0, float('inf'), float('inf'))
+
+assert_raises(TypeError, lambda: slice(0) < 3)
+assert_raises(TypeError, lambda: slice(0) > 3)
+assert_raises(TypeError, lambda: slice(0) <= 3)
+assert_raises(TypeError, lambda: slice(0) >= 3)
+
+assert_raises(TypeError, hash, slice(0))
+assert_raises(TypeError, hash, slice(None))
+
+def dict_slice():
+    d = {}
+    d[slice(0)] = 3
+
+assert_raises(TypeError, dict_slice)
+
+assert slice(None           ).indices(10) == (0, 10,  1)
+assert slice(None,  None,  2).indices(10) == (0, 10,  2)
+assert slice(1,     None,  2).indices(10) == (1, 10,  2)
+assert slice(None,  None, -1).indices(10) == (9, -1, -1)
+assert slice(None,  None, -2).indices(10) == (9, -1, -2)
+assert slice(3,     None, -2).indices(10) == (3, -1, -2)
+
+# issue 3004 tests
+assert slice(None, -9).indices(10) == (0, 1, 1)
+assert slice(None, -10).indices(10) == (0, 0, 1)
+assert slice(None, -11).indices(10) == (0, 0, 1)
+assert slice(None, -10, -1).indices(10) == (9, 0, -1)
+assert slice(None, -11, -1).indices(10) == (9, -1, -1)
+assert slice(None, -12, -1).indices(10) == (9, -1, -1)
+assert slice(None, 9).indices(10) == (0, 9, 1)
+assert slice(None, 10).indices(10) == (0, 10, 1)
+assert slice(None, 11).indices(10) == (0, 10, 1)
+assert slice(None, 8, -1).indices(10) == (9, 8, -1)
+assert slice(None, 9, -1).indices(10) == (9, 9, -1)
+assert slice(None, 10, -1).indices(10) == (9, 9, -1)
+
+assert \
+    slice(-100,  100).indices(10) == \
+    slice(None      ).indices(10)
+
+assert \
+    slice(100,  -100,  -1).indices(10) == \
+    slice(None, None, -1).indices(10)
+
+assert slice(-100, 100, 2).indices(10) == (0, 10,  2)
+
+try:
+	slice(None, None, 0)
+	assert "zero step" == "throws an exception"
+except:
+	pass
+
 a = []
-assert a[:] == []
-assert a[: 2 ** 100] == []
-assert a[-2 ** 100 :] == []
-assert a[:: 2 ** 100] == []
-assert a[10:20] == []
-assert a[-20:-10] == []
-
 b = [1, 2]
-
-assert b[:] == [1, 2]
-assert b[slice(None)] == [1, 2]
-assert b[: 2 ** 100] == [1, 2]
-assert b[-2 ** 100 :] == [1, 2]
-assert b[2 ** 100 :] == []
-assert b[:: 2 ** 100] == [1]
-assert b[-10:1] == [1]
-assert b[0:0] == []
-assert b[1:0] == []
-
-assert_raises(ValueError, lambda: b[::0], _msg='zero step slice')
-
-assert b[::-1] == [2, 1]
-assert b[1::-1] == [2, 1]
-assert b[0::-1] == [1]
-assert b[0:-5:-1] == [1]
-assert b[:0:-1] == [2]
-assert b[5:0:-1] == [2]
-
 c = list(range(10))
-
-assert c[9:6:-3] == [9]
-assert c[9::-3] == [9, 6, 3, 0]
-assert c[9::-4] == [9, 5, 1]
-assert c[8 :: -2 ** 100] == [8]
-
-assert c[7:7:-2] == []
-assert c[7:8:-2] == []
-
 d = "123456"
 
-assert d[3::-1] == "4321"
-assert d[4::-3] == "52"
-
-assert [1, 2, 3, 5, 6][-1:-5:-1] == [6, 5, 3, 2]  # #746
-
 slice_a = slice(5)
 assert slice_a.start is None
 assert slice_a.stop == 5

extra_tests/snippets/builtin_type.py

@@ -100,6 +100,126 @@ assert D.__module__ == 'd'
 assert D.__qualname__ == 'DD'
 
 
+from testutils import assert_raises
+
+import platform
+if platform.python_implementation() == 'RustPython':
+    gc = None
+else:
+    import gc
+
+assert type(type) is type
+assert type(object) is type
+assert type(object()) is object
+
+new_type = type('New', (object,), {})
+
+assert type(new_type) is type
+assert type(new_type()) is new_type
+
+metaclass = type('MCl', (type,), {})
+cls = metaclass('Cls', (object,), {})
+inst = cls()
+
+assert type(inst) is cls
+assert type(cls) is metaclass
+assert type(metaclass) is type
+
+assert issubclass(metaclass, type)
+assert isinstance(cls, type)
+
+assert inst.__class__ is cls
+assert cls.__class__ is metaclass
+assert metaclass.__class__ is type
+assert type.__class__ is type
+assert None.__class__ is type(None)
+
+assert isinstance(type, type)
+assert issubclass(type, type)
+
+assert not isinstance(type, (int, float))
+assert isinstance(type, (int, object))
+
+assert not issubclass(type, (int, float))
+assert issubclass(type, (int, type))
+
+class A: pass
+class B(A): pass
+class C(A): pass
+class D(B, C): pass
+
+assert A.__subclasses__() == [B, C]
+assert B.__subclasses__() == [D]
+assert C.__subclasses__() == [D]
+assert D.__subclasses__() == []
+
+assert D.__bases__ == (B, C)
+assert A.__bases__ == (object,)
+assert B.__bases__ == (A,)
+
+
+del D
+
+if gc:
+    # gc sweep is needed here for CPython...
+    gc.collect()
+    # ...while RustPython doesn't have `gc` yet. 
+
+if gc:
+    # D.__new__ is a method bound to the D type, so just deleting D
+    # from globals won't actually invalidate the weak reference that
+    # subclasses holds. TODO: implement a proper tracing gc
+    assert B.__subclasses__() == []
+    assert C.__subclasses__() == []
+
+assert type in object.__subclasses__()
+
+assert cls.__name__ == 'Cls'
+
+# mro
+assert int.mro() == [int, object]
+assert bool.mro() == [bool, int, object]
+assert object.mro() == [object]
+
+class A:
+    pass
+
+class B(A):
+    pass
+
+assert A.mro() == [A, object]
+assert B.mro() == [B, A, object]
+
+class AA:
+    pass
+
+class BB(AA):
+    pass
+
+class C(B, BB):
+    pass
+
+assert C.mro() == [C, B, A, BB, AA, object]
+
+
+assert type(Exception.args).__name__ == 'getset_descriptor'
+assert type(None).__bool__(None) is False
+
+class A:
+    pass
+
+class B:
+    pass
+
+a = A()
+a.__class__ = B
+assert isinstance(a, B)
+
+b = 1
+with assert_raises(TypeError):
+    b.__class__ = B
+
+
 # Regression to
 # https://github.com/RustPython/RustPython/issues/2310
 import builtins

extra_tests/snippets/comparisons.py

@@ -1,23 +0,0 @@
-from testutils import assert_raises
-
-assert 1 < 2
-assert 1 < 2 < 3
-assert 5 == 5 == 5
-assert (5 == 5) == True
-assert 5 == 5 != 4 == 4 > 3 > 2 < 3 <= 3 != 0 == 0
-
-assert not 1 > 2
-assert not 5 == 5 == True
-assert not 5 == 5 != 5 == 5
-assert not 1 < 2 < 3 > 4
-assert not 1 < 2 > 3 < 4
-assert not 1 > 2 < 3 < 4
-
-def test_type_error(x, y):
-    assert_raises(TypeError, lambda: x < y)
-    assert_raises(TypeError, lambda: x <= y)
-    assert_raises(TypeError, lambda: x > y)
-    assert_raises(TypeError, lambda: x >= y)
-
-test_type_error([], 0)
-test_type_error((), 0)

extra_tests/snippets/complex.py

@@ -1,15 +0,0 @@
-import testutils
-
-# __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/derived_mc.py

@@ -1,45 +0,0 @@
-class MC(type):
-    pass
-
-class MC2(MC):
-    pass
-
-class MC3(type):
-    pass
-
-class A():
-    pass
-
-assert type(A) == type
-
-class B(metaclass=MC):
-    pass
-
-assert type(B) == MC
-
-class C(B):
-    pass
-
-assert type(C) == MC
-
-class D(metaclass=MC2):
-    pass
-
-assert type(D) == MC2
-
-class E(C, D, metaclass=MC):
-    pass
-
-assert type(E) == MC2
-
-class F(metaclass=MC3):
-    pass
-
-assert type(F) == MC3
-
-try:
-    class G(D, E, F):
-        pass
-    assert False
-except TypeError:
-    pass

extra_tests/snippets/example_interactive.py

@@ -18,7 +18,7 @@ assert c2.co_argcount == 2
 assert "Constant String" in c2.co_consts, c2.co_consts
 print(c2.co_consts)
 assert 2 in c2.co_consts, c2.co_consts
-assert "code.py" in c2.co_filename
+assert "example_interactive.py" in c2.co_filename
 assert c2.co_firstlineno == 5, str(c2.co_firstlineno)
 # assert isinstance(c2.co_flags, int) # 'OPTIMIZED, NEWLOCALS, NOFREE'
 # assert c2.co_freevars == (), str(c2.co_freevars)

extra_tests/snippets/minimum.py

@@ -1 +0,0 @@
-1

extra_tests/snippets/operator_comparison.py

@@ -1,3 +1,28 @@
+from testutils import assert_raises
+
+assert 1 < 2
+assert 1 < 2 < 3
+assert 5 == 5 == 5
+assert (5 == 5) == True
+assert 5 == 5 != 4 == 4 > 3 > 2 < 3 <= 3 != 0 == 0
+
+assert not 1 > 2
+assert not 5 == 5 == True
+assert not 5 == 5 != 5 == 5
+assert not 1 < 2 < 3 > 4
+assert not 1 < 2 > 3 < 4
+assert not 1 > 2 < 3 < 4
+
+def test_type_error(x, y):
+    assert_raises(TypeError, lambda: x < y)
+    assert_raises(TypeError, lambda: x <= y)
+    assert_raises(TypeError, lambda: x > y)
+    assert_raises(TypeError, lambda: x >= y)
+
+test_type_error([], 0)
+test_type_error((), 0)
+
+
 # 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

extra_tests/snippets/slice.py

@@ -1,130 +0,0 @@
-from testutils import assert_raises
-import itertools
-
-a = slice(10)
-assert a.start == None
-assert a.stop == 10
-assert a.step == None
-
-a = slice(0, 10, 1)
-assert a.start == 0
-assert a.stop == 10
-assert a.step == 1
-
-assert slice(10).__repr__() == 'slice(None, 10, None)'
-assert slice(None).__repr__() == 'slice(None, None, None)'
-assert slice(0, 10, 13).__repr__() == 'slice(0, 10, 13)'
-assert slice('0', 1.1, 2+3j).__repr__() == "slice('0', 1.1, (2+3j))"
-
-assert slice(10) == slice(10)
-assert slice(-1) != slice(1)
-assert slice(0, 10, 3) != slice(0, 11, 3)
-assert slice(0, None, 3) != slice(0, 'a', 3)
-assert slice(0, 'a', 3) == slice(0, 'a', 3)
-
-assert slice(0, 0, 0).__eq__(slice(0, 0, 0))
-assert not slice(0, 0, 1).__eq__(slice(0, 0, 0))
-assert not slice(0, 1, 0).__eq__(slice(0, 0, 0))
-assert not slice(1, 0, 0).__eq__(slice(0, 0, 0))
-assert slice(1, 0, 0).__ne__(slice(0, 0, 0))
-assert slice(0, 1, 0).__ne__(slice(0, 0, 0))
-assert slice(0, 0, 1).__ne__(slice(0, 0, 0))
-
-assert slice(0).__eq__(0) == NotImplemented
-assert slice(0).__ne__(0) == NotImplemented
-assert slice(None).__ne__(slice(0))
-
-# slice gt, ge, lt, le
-assert_raises(TypeError, lambda: slice(0, slice(), 0) < slice(0, 0, 0))
-assert_raises(TypeError, lambda: slice(0, slice(), 0) <= slice(0, 0, 0))
-assert_raises(TypeError, lambda: slice(0, slice(), 0) > slice(0, 0, 0))
-assert_raises(TypeError, lambda: slice(0, slice(), 0) >= slice(0, 0, 0))
-
-assert_raises(TypeError, lambda: slice(0, 0, 0) < slice(0, 0, slice()))
-assert_raises(TypeError, lambda: slice(0, 0, 0) <= slice(0, 0, slice()))
-assert_raises(TypeError, lambda: slice(0, 0, 0) > slice(0, 0, slice()))
-assert_raises(TypeError, lambda: slice(0, 0, 0) >= slice(0, 0, slice()))
-
-assert_raises(TypeError, lambda: slice(0, 0) >= slice(0, 0, 0))
-assert_raises(TypeError, lambda: slice(0, 0) <= slice(0, 0, 0))
-assert_raises(TypeError, lambda: slice(0, 0) < slice(0, 0, 0))
-assert_raises(TypeError, lambda: slice(0, 0) > slice(0, 0, 0))
-
-assert slice(0, 0, 0) < slice(0, 1, -1)
-assert slice(0, 0, 0) < slice(0, 0, 1)
-assert slice(0, 0, 0) > slice(0, 0, -1)
-assert slice(0, 0, 0) >= slice(0, 0, -1)
-assert not slice(0, 0, 0) <= slice(0, 0, -1)
-
-assert slice(0, 0, 0) > slice(0, -1, 1)
-assert slice(0, 0, 0) >= slice(0, -1, 1)
-assert slice(0, 0, 0) >= slice(0, -1, 1)
-
-assert slice(0, 0, 0) <= slice(0, 0, 1)
-assert slice(0, 0, 0) <= slice(0, 0, 0)
-assert slice(0, 0, 0) <= slice(0, 0, 0)
-assert not slice(0, 0, 0) > slice(0, 0, 0)
-assert not slice(0, 0, 0) < slice(0, 0, 0)
-
-assert not slice(0, float('nan'), float('nan')) <= slice(0, float('nan'), 1)
-assert not slice(0, float('nan'), float('nan')) <= slice(0, float('nan'), float('nan'))
-assert not slice(0, float('nan'), float('nan')) >= slice(0, float('nan'), float('nan'))
-assert not slice(0, float('nan'), float('nan')) < slice(0, float('nan'), float('nan'))
-assert not slice(0, float('nan'), float('nan')) > slice(0, float('nan'), float('nan'))
-
-assert slice(0, float('inf'), float('inf')) >= slice(0, float('inf'), 1)
-assert slice(0, float('inf'), float('inf')) <= slice(0, float('inf'), float('inf'))
-assert slice(0, float('inf'), float('inf')) >= slice(0, float('inf'), float('inf'))
-assert not slice(0, float('inf'), float('inf')) < slice(0, float('inf'), float('inf'))
-assert not slice(0, float('inf'), float('inf')) > slice(0, float('inf'), float('inf'))
-
-assert_raises(TypeError, lambda: slice(0) < 3)
-assert_raises(TypeError, lambda: slice(0) > 3)
-assert_raises(TypeError, lambda: slice(0) <= 3)
-assert_raises(TypeError, lambda: slice(0) >= 3)
-
-assert_raises(TypeError, hash, slice(0))
-assert_raises(TypeError, hash, slice(None))
-
-def dict_slice():
-    d = {}
-    d[slice(0)] = 3
-
-assert_raises(TypeError, dict_slice)
-
-assert slice(None           ).indices(10) == (0, 10,  1)
-assert slice(None,  None,  2).indices(10) == (0, 10,  2)
-assert slice(1,     None,  2).indices(10) == (1, 10,  2)
-assert slice(None,  None, -1).indices(10) == (9, -1, -1)
-assert slice(None,  None, -2).indices(10) == (9, -1, -2)
-assert slice(3,     None, -2).indices(10) == (3, -1, -2)
-
-# issue 3004 tests
-assert slice(None, -9).indices(10) == (0, 1, 1)
-assert slice(None, -10).indices(10) == (0, 0, 1)
-assert slice(None, -11).indices(10) == (0, 0, 1)
-assert slice(None, -10, -1).indices(10) == (9, 0, -1)
-assert slice(None, -11, -1).indices(10) == (9, -1, -1)
-assert slice(None, -12, -1).indices(10) == (9, -1, -1)
-assert slice(None, 9).indices(10) == (0, 9, 1)
-assert slice(None, 10).indices(10) == (0, 10, 1)
-assert slice(None, 11).indices(10) == (0, 10, 1)
-assert slice(None, 8, -1).indices(10) == (9, 8, -1)
-assert slice(None, 9, -1).indices(10) == (9, 9, -1)
-assert slice(None, 10, -1).indices(10) == (9, 9, -1)
-
-assert \
-    slice(-100,  100).indices(10) == \
-    slice(None      ).indices(10)
-
-assert \
-    slice(100,  -100,  -1).indices(10) == \
-    slice(None, None, -1).indices(10)
-
-assert slice(-100, 100, 2).indices(10) == (0, 10,  2)
-
-try:
-	slice(None, None, 0)
-	assert "zero step" == "throws an exception"
-except:
-	pass

extra_tests/snippets/syntax_metaclass.py

@@ -29,3 +29,49 @@ assert C().count == 2
 
 assert C.prepared
 assert D.prepared
+
+class MC(type):
+    pass
+
+class MC2(MC):
+    pass
+
+class MC3(type):
+    pass
+
+class A():
+    pass
+
+assert type(A) == type
+
+class B(metaclass=MC):
+    pass
+
+assert type(B) == MC
+
+class C(B):
+    pass
+
+assert type(C) == MC
+
+class D(metaclass=MC2):
+    pass
+
+assert type(D) == MC2
+
+class E(C, D, metaclass=MC):
+    pass
+
+assert type(E) == MC2
+
+class F(metaclass=MC3):
+    pass
+
+assert type(F) == MC3
+
+try:
+    class G(D, E, F):
+        pass
+    assert False
+except TypeError:
+    pass

extra_tests/snippets/syntax_slice.py

@@ -0,0 +1,47 @@
+from testutils import assert_raises
+
+a = []
+assert a[:] == []
+assert a[: 2 ** 100] == []
+assert a[-2 ** 100 :] == []
+assert a[:: 2 ** 100] == []
+assert a[10:20] == []
+assert a[-20:-10] == []
+
+b = [1, 2]
+
+assert b[:] == [1, 2]
+assert b[slice(None)] == [1, 2]
+assert b[: 2 ** 100] == [1, 2]
+assert b[-2 ** 100 :] == [1, 2]
+assert b[2 ** 100 :] == []
+assert b[:: 2 ** 100] == [1]
+assert b[-10:1] == [1]
+assert b[0:0] == []
+assert b[1:0] == []
+
+assert_raises(ValueError, lambda: b[::0], _msg='zero step slice')
+
+assert b[::-1] == [2, 1]
+assert b[1::-1] == [2, 1]
+assert b[0::-1] == [1]
+assert b[0:-5:-1] == [1]
+assert b[:0:-1] == [2]
+assert b[5:0:-1] == [2]
+
+c = list(range(10))
+
+assert c[9:6:-3] == [9]
+assert c[9::-3] == [9, 6, 3, 0]
+assert c[9::-4] == [9, 5, 1]
+assert c[8 :: -2 ** 100] == [8]
+
+assert c[7:7:-2] == []
+assert c[7:8:-2] == []
+
+d = "123456"
+
+assert d[3::-1] == "4321"
+assert d[4::-3] == "52"
+
+assert [1, 2, 3, 5, 6][-1:-5:-1] == [6, 5, 3, 2]  # #746

extra_tests/snippets/types_snippet.py

@@ -1,118 +0,0 @@
-from testutils import assert_raises
-
-import platform
-if platform.python_implementation() == 'RustPython':
-    gc = None
-else:
-    import gc
-
-assert type(type) is type
-assert type(object) is type
-assert type(object()) is object
-
-new_type = type('New', (object,), {})
-
-assert type(new_type) is type
-assert type(new_type()) is new_type
-
-metaclass = type('MCl', (type,), {})
-cls = metaclass('Cls', (object,), {})
-inst = cls()
-
-assert type(inst) is cls
-assert type(cls) is metaclass
-assert type(metaclass) is type
-
-assert issubclass(metaclass, type)
-assert isinstance(cls, type)
-
-assert inst.__class__ is cls
-assert cls.__class__ is metaclass
-assert metaclass.__class__ is type
-assert type.__class__ is type
-assert None.__class__ is type(None)
-
-assert isinstance(type, type)
-assert issubclass(type, type)
-
-assert not isinstance(type, (int, float))
-assert isinstance(type, (int, object))
-
-assert not issubclass(type, (int, float))
-assert issubclass(type, (int, type))
-
-class A: pass
-class B(A): pass
-class C(A): pass
-class D(B, C): pass
-
-assert A.__subclasses__() == [B, C]
-assert B.__subclasses__() == [D]
-assert C.__subclasses__() == [D]
-assert D.__subclasses__() == []
-
-assert D.__bases__ == (B, C)
-assert A.__bases__ == (object,)
-assert B.__bases__ == (A,)
-
-
-del D
-
-if gc:
-    # gc sweep is needed here for CPython...
-    gc.collect()
-    # ...while RustPython doesn't have `gc` yet. 
-
-if gc:
-    # D.__new__ is a method bound to the D type, so just deleting D
-    # from globals won't actually invalidate the weak reference that
-    # subclasses holds. TODO: implement a proper tracing gc
-    assert B.__subclasses__() == []
-    assert C.__subclasses__() == []
-
-assert type in object.__subclasses__()
-
-assert cls.__name__ == 'Cls'
-
-# mro
-assert int.mro() == [int, object]
-assert bool.mro() == [bool, int, object]
-assert object.mro() == [object]
-
-class A:
-    pass
-
-class B(A):
-    pass
-
-assert A.mro() == [A, object]
-assert B.mro() == [B, A, object]
-
-class AA:
-    pass
-
-class BB(AA):
-    pass
-
-class C(B, BB):
-    pass
-
-assert C.mro() == [C, B, A, BB, AA, object]
-
-
-assert type(Exception.args).__name__ == 'getset_descriptor'
-assert type(None).__bool__(None) is False
-
-class A:
-    pass
-
-class B:
-    pass
-
-a = A()
-a.__class__ = B
-assert isinstance(a, B)
-
-b = 1
-with assert_raises(TypeError):
-    b.__class__ = B

extra_tests/snippets/variables.py

@@ -1,4 +0,0 @@
-a = 8
-b = 7
-assert a+b == 15
-# print(a+b)