superacli 1.1.5 → 1.1.7

package/ref-monty/crates/monty/test_cases/refcount__kwargs_unpacking.py

@@ -1,27 +0,0 @@
-# Tests reference counting correctness for **kwargs unpacking
-
-
-def receive_kwargs(a, b, c):
-    return a
-
-
-# === Heap-allocated values in unpacked dict ===
-# All heap objects must be directly referenced by variables for strict matching
-list_a = [1, 2, 3]
-list_c = [4, 5]
-kwargs_dict = {'a': list_a, 'b': 'hello', 'c': list_c}
-result = receive_kwargs(**kwargs_dict)
-assert result == [1, 2, 3], 'received list via **kwargs'
-assert result is list_a, 'should be same object'
-
-# Second call to verify dict reuse works
-result2 = receive_kwargs(**kwargs_dict)
-assert result2 is list_a, 'second call returns same object'
-
-# list_a: 5 refs (list_a var, kwargs_dict['a'], result, result2, final expr)
-# list_c: 2 refs (list_c var, kwargs_dict['c'])
-# kwargs_dict: 1 ref
-# result: 5 refs (same object as list_a)
-# result2: 5 refs (same object as list_a)
-result2
-# ref-counts={'list_a': 5, 'list_c': 2, 'kwargs_dict': 1, 'result': 5, 'result2': 5}

package/ref-monty/crates/monty/test_cases/refcount__list_append_multiple.py

@@ -1,6 +0,0 @@
-item = [1]
-lst = []
-lst.append(item)
-lst.append(item)
-lst
-# ref-counts={'item': 3, 'lst': 2}

package/ref-monty/crates/monty/test_cases/refcount__list_append_ref.py

@@ -1,5 +0,0 @@
-item = [1]
-lst = []
-lst.append(item)
-lst
-# ref-counts={'item': 2, 'lst': 2}

package/ref-monty/crates/monty/test_cases/refcount__list_concat.py

@@ -1,5 +0,0 @@
-a = [1]
-b = [2]
-c = a + b
-c
-# ref-counts={'a': 1, 'b': 1, 'c': 2}

package/ref-monty/crates/monty/test_cases/refcount__list_getitem.py

@@ -1,5 +0,0 @@
-item = [1, 2]
-lst = [item]
-x = lst[0]
-x
-# ref-counts={'item': 4, 'lst': 1, 'x': 4}

package/ref-monty/crates/monty/test_cases/refcount__list_iadd.py

@@ -1,5 +0,0 @@
-a = [1]
-b = [2]
-a += b
-a
-# ref-counts={'a': 2, 'b': 1}

package/ref-monty/crates/monty/test_cases/refcount__nested_list.py

@@ -1,4 +0,0 @@
-inner = [1, 2]
-outer = [inner, inner]
-outer
-# ref-counts={'inner': 3, 'outer': 2}

package/ref-monty/crates/monty/test_cases/refcount__re_pattern_sub_error_paths.py

@@ -1,37 +0,0 @@
-# Tests reference counting on Pattern.sub error paths.
-#
-# The positional arg iterator and extra args must be properly dropped even
-# when Pattern.sub raises due to too many args or a bad count type.
-# These paths previously leaked because pos.next().is_some() consumed a
-# Value without dropping it.
-
-import re
-
-# Use lists as heap-allocated values we can track
-repl_list = ['replacement']
-input_list = ['the input']
-p = re.compile('hello')
-
-# Exercise error path: too many positional arguments
-try:
-    p.sub('repl', 'string', 0, 'extra')
-except TypeError:
-    pass
-
-# Exercise error path: bad count type
-try:
-    p.sub('repl', 'string', 'bad')
-except TypeError:
-    pass
-
-# Exercise negative count path (early return)
-result = p.sub('repl', 'hello', -1)
-assert result == 'hello', 'negative count returns input unchanged'
-
-# repl_list: 1 (variable)
-# input_list: 1 (variable)
-# p: 1 (variable)
-# re: 1 (module)
-# result: 2 (variable + final expression)
-result
-# ref-counts={'repl_list': 1, 'input_list': 1, 'p': 1, 're': 1, 'result': 2}

package/ref-monty/crates/monty/test_cases/refcount__re_search_match.py

@@ -1,34 +0,0 @@
-# Tests reference counting for re.search, re.match, and re.fullmatch.
-#
-# Verifies that Match objects, Pattern objects, and intermediate strings
-# are correctly reference-counted through normal usage paths.
-# All heap objects must be directly referenced by variables for strict matching.
-
-import re
-
-# Compile a pattern and run search — both pattern and match stay alive
-p = re.compile(r'(\w+)')
-m = p.search('hello world')
-assert m is not None, 'search finds match'
-group_str = m.group(0)
-assert group_str == 'hello', 'group(0) returns matched text'
-
-# Run fullmatch — exercises the compiled_fullmatch regex path
-m2 = p.fullmatch('hello')
-assert m2 is not None, 'fullmatch finds match'
-full_str = m2.group(0)
-assert full_str == 'hello', 'fullmatch group(0) returns matched text'
-
-# findall returns a list — keep individual elements in variables
-# so strict matching passes (all heap objects must be reachable)
-results = p.findall('a b c')
-assert results == ['a', 'b', 'c'], 'findall returns list of matches'
-r0 = results[0]
-r1 = results[1]
-r2 = results[2]
-
-# p: 1, m: 1, group_str: 1, m2: 1, full_str: 1
-# results: 1, r0: 2 (var + list), r1: 2 (var + list), r2: 2 (var + list + final expr)
-# re: 1
-r2
-# ref-counts={'p': 1, 'm': 1, 'group_str': 1, 'm2': 1, 'full_str': 1, 'results': 1, 'r0': 2, 'r1': 2, 'r2': 3, 're': 1}

package/ref-monty/crates/monty/test_cases/refcount__re_sub_error_paths.py

@@ -1,31 +0,0 @@
-# Tests reference counting on re.sub error paths.
-#
-# The positional arg iterator and extra args must be properly dropped even
-# when re.sub raises due to too many args or a bad count type.
-# These paths previously leaked because pos.next().is_some() consumed a
-# Value without dropping it, and the pos iterator itself was unguarded.
-
-import re
-
-# Use lists as heap-allocated values that we can track through error paths.
-# String literals may be interned and won't show up in heap ref counts.
-repl_list = ['replacement']
-input_list = ['the input']
-
-# Exercise error path: bad count type with heap-allocated args in scope
-try:
-    re.sub('pattern', 'repl', 'input', 'bad')
-except TypeError:
-    pass
-
-# Exercise negative count path (early return, no regex compilation)
-result = re.sub('pattern', 'repl', 'hello', -1)
-assert result == 'hello', 'negative count returns input unchanged'
-
-# All lists should still be alive and reachable
-# repl_list: 1 (variable)
-# input_list: 1 (variable)
-# re: 1 (module)
-# result: 2 (variable + final expression)
-result
-# ref-counts={'repl_list': 1, 'input_list': 1, 're': 1, 'result': 2}

package/ref-monty/crates/monty/test_cases/refcount__shared_reference.py

@@ -1,4 +0,0 @@
-x = [1, 2, 3]
-y = x
-x
-# ref-counts={'x': 3, 'y': 3}

package/ref-monty/crates/monty/test_cases/refcount__single_list.py

@@ -1,3 +0,0 @@
-x = [1, 2, 3]
-x
-# ref-counts={'x': 2}

package/ref-monty/crates/monty/test_cases/repr__cycle_detection.py

@@ -1,24 +0,0 @@
-# Test cycle detection in repr for self-referential structures
-
-# Section 1: List self-reference
-a = []
-a.append(a)
-assert repr(a) == '[[...]]', 'list self-reference'
-
-# Section 2: Dict self-reference
-d = {}
-d['self'] = d
-assert repr(d) == "{'self': {...}}", 'dict self-reference'
-
-# Section 3: Composite - list containing dict containing original list
-c = []
-e = {'list': c}
-c.append(e)
-assert repr(c) == "[{'list': [...]}]", 'list containing dict cycle'
-assert repr(e) == "{'list': [{...}]}", 'dict containing list cycle'
-
-# Section 4: Multiple references to same cyclic object
-f = []
-f.append(f)
-g = [f, f]
-assert repr(g) == '[[[...]], [[...]]]', 'multiple refs to cyclic list'

package/ref-monty/crates/monty/test_cases/set__ops.py

@@ -1,191 +0,0 @@
-# === Construction ===
-s = set()
-assert len(s) == 0, 'empty set len'
-assert s == set(), 'empty set equality'
-
-s = set([1, 2, 3])
-assert len(s) == 3, 'set from list len'
-
-# === Basic Methods ===
-s = set()
-s.add(1)
-s.add(2)
-s.add(1)  # duplicate
-assert len(s) == 2, 'add with duplicate'
-
-# === Discard and Remove ===
-s = set([1, 2, 3])
-s.discard(2)
-assert len(s) == 2, 'discard existing'
-s.discard(99)  # should not raise
-assert len(s) == 2, 'discard non-existing'
-
-# === Pop ===
-s = set([1])
-v = s.pop()
-assert v == 1, 'pop returns element'
-assert len(s) == 0, 'pop removes element'
-
-# === Clear ===
-s = set([1, 2, 3])
-s.clear()
-assert len(s) == 0, 'clear'
-
-# === Copy ===
-s = set([1, 2, 3])
-s2 = s.copy()
-assert s == s2, 'copy equality'
-s.add(4)
-assert s != s2, 'copy is independent'
-
-# === Update ===
-s = set([1, 2])
-s.update([2, 3, 4])
-assert len(s) == 4, 'update with list'
-
-# === Union ===
-s1 = set([1, 2])
-s2 = set([2, 3])
-u = s1.union(s2)
-assert len(u) == 3, 'union len'
-
-# === Intersection ===
-s1 = set([1, 2, 3])
-s2 = set([2, 3, 4])
-i = s1.intersection(s2)
-assert len(i) == 2, 'intersection len'
-
-# === Difference ===
-s1 = set([1, 2, 3])
-s2 = set([2, 3, 4])
-d = s1.difference(s2)
-assert len(d) == 1, 'difference len'
-
-# === Symmetric Difference ===
-s1 = set([1, 2, 3])
-s2 = set([2, 3, 4])
-sd = s1.symmetric_difference(s2)
-assert len(sd) == 2, 'symmetric_difference len'
-
-# === Binary operators ===
-s = {1, 2}
-t = {2, 3}
-fs = frozenset([2, 3])
-
-assert s & t == {2}, 'set & set works'
-assert s | t == {1, 2, 3}, 'set | set works'
-assert s ^ t == {1, 3}, 'set ^ set works'
-assert s - t == {1}, 'set - set works'
-
-assert s & fs == {2}, 'set & frozenset works'
-assert s | fs == {1, 2, 3}, 'set | frozenset works'
-assert s ^ fs == {1, 3}, 'set ^ frozenset works'
-assert s - fs == {1}, 'set - frozenset works'
-
-keys = {'a': 1, 'b': 2}.keys()
-items = {'a': 1, 'b': 2}.items()
-assert {'a'} & keys == {'a'}, 'set & dict_keys works'
-assert {'a'} | keys == {'a', 'b'}, 'set | dict_keys works'
-assert {('a', 1)} ^ items == {('b', 2)}, 'set ^ dict_items works'
-assert {('a', 1), ('b', 2)} - items == set(), 'set - dict_items works'
-
-assert type(s & fs).__name__ == 'set', 'set operators keep the left operand type'
-
-try:
-    s & [1, 2]
-    assert False, 'set operators reject non-set rhs'
-except TypeError as e:
-    assert str(e) == "unsupported operand type(s) for &: 'set' and 'list'", 'set & rhs error matches CPython'
-
-try:
-    s | [1, 2]
-    assert False, 'set union operator rejects non-set rhs'
-except TypeError as e:
-    assert str(e) == "unsupported operand type(s) for |: 'set' and 'list'", 'set | rhs error matches CPython'
-
-try:
-    s ^ [1, 2]
-    assert False, 'set xor operator rejects non-set rhs'
-except TypeError as e:
-    assert str(e) == "unsupported operand type(s) for ^: 'set' and 'list'", 'set ^ rhs error matches CPython'
-
-try:
-    s - [1, 2]
-    assert False, 'set subtraction operator rejects non-set rhs'
-except TypeError as e:
-    assert str(e) == "unsupported operand type(s) for -: 'set' and 'list'", 'set - rhs error matches CPython'
-
-# === Issubset ===
-s1 = set([1, 2])
-s2 = set([1, 2, 3])
-assert s1.issubset(s2) == True, 'issubset true'
-assert s2.issubset(s1) == False, 'issubset false'
-
-# === Issuperset ===
-s1 = set([1, 2, 3])
-s2 = set([1, 2])
-assert s1.issuperset(s2) == True, 'issuperset true'
-assert s2.issuperset(s1) == False, 'issuperset false'
-
-# === Isdisjoint ===
-s1 = set([1, 2])
-s2 = set([3, 4])
-s3 = set([2, 3])
-assert s1.isdisjoint(s2) == True, 'isdisjoint true'
-assert s1.isdisjoint(s3) == False, 'isdisjoint false'
-
-# === Bool ===
-assert bool(set()) == False, 'empty set is falsy'
-assert bool(set([1])) == True, 'non-empty set is truthy'
-
-# === repr ===
-assert repr(set()) == 'set()', 'empty set repr'
-
-# === Set literals ===
-s = {1, 2, 3}
-assert len(s) == 3, 'set literal len'
-
-s = {1, 1, 2, 2, 3}
-assert len(s) == 3, 'set literal deduplication'
-
-# Set literal with expressions
-x = 5
-s = {x, x + 1, x + 2}
-assert len(s) == 3, 'set literal with expressions'
-
-# === Set unpacking (PEP 448) ===
-a = [1, 2]
-b = [3, 4]
-assert {*a} == {1, 2}, 'single set unpack from list'
-assert {*a, *b} == {1, 2, 3, 4}, 'double set unpack'
-assert {0, *a, 5} == {0, 1, 2, 5}, 'mixed set unpack'
-assert {*[]} == set(), 'unpack empty into set'
-assert {*(1, 2)} == {1, 2}, 'unpack tuple into set'
-assert {*{'a': 1, 'b': 2}} == {'a', 'b'}, 'unpack dict keys into set'
-assert {*'aab'} == {'a', 'b'}, 'unpack string into set'
-# Heap-allocated set: covers the HeapData::Set arm in set_extend
-inner_set = {1, 2, 3}
-assert {*inner_set} == {1, 2, 3}, 'unpack set into set'
-# Heap-allocated Str (result of concat, not interned): covers HeapData::Str in set_extend
-hs = 'hel' + 'lo'
-assert {*hs} == {'h', 'e', 'l', 'o'}, 'unpack heap string into set'
-
-
-# Non-iterable heap-allocated Ref (closure) hits the inner `_` arm in set_extend.
-# A plain top-level function is Value::DefFunction (not a Ref), so a closure is
-# required to reach the Value::Ref(_) branch (HeapData that is not List/Tuple/Set/Dict/Str).
-def _make_set_unpack_closure():
-    _sentinel = 1
-
-    def _inner():
-        return _sentinel
-
-    return _inner
-
-
-_set_unpack_closure = _make_set_unpack_closure()
-try:
-    _x = {*_set_unpack_closure}
-    assert False, 'expected TypeError for non-iterable heap closure in set unpack'
-except TypeError:
-    pass

package/ref-monty/crates/monty/test_cases/set__review_bugs.py

@@ -1,35 +0,0 @@
-# Tests for review issues
-
-# === frozenset repr for non-empty sets ===
-# frozenset repr should show "frozenset({...})" not just "{...}"
-fs_repr = repr(frozenset({1, 2}))
-assert fs_repr == 'frozenset({1, 2})' or fs_repr == 'frozenset({2, 1})', 'frozenset repr should include type name'
-assert repr(frozenset()) == 'frozenset()', 'empty frozenset repr'
-
-# set repr should NOT have type prefix
-s_repr = repr({1, 2})
-assert s_repr == '{1, 2}' or s_repr == '{2, 1}', 'set repr should not have prefix'
-
-# === issubset with range (non-Ref iterable) ===
-# These should work, not raise TypeError
-s = {1, 2, 3}
-assert s.issubset(range(10)), 'issubset should accept range'
-assert s.issuperset(range(1, 3)), 'issuperset should accept range'
-assert s.isdisjoint(range(10, 20)), 'isdisjoint should accept range'
-
-# === set construction with nested heap objects ===
-# This tests ref counting - if refs are dropped before incrementing, this will fail
-t = (1, 2)
-s = set([t])
-assert len(s) == 1, 'set should have one element'
-assert repr(s) == '{(1, 2)}', 'set repr should not have prefix'
-
-# More complex case - the list is temporary and will be dropped
-s2 = set([(3, 4)])
-assert len(s2) == 1, 'set from temp list should have one element'
-assert repr(s2) == '{(3, 4)}', 'set repr should not have prefix'
-
-# frozenset with nested objects
-fs = frozenset([(5, 6)])
-assert len(fs) == 1, 'frozenset from temp list should have one element'
-assert repr(fs) == 'frozenset({(5, 6)})', 'frozenset repr should not have prefix'

package/ref-monty/crates/monty/test_cases/set__unpack_type_error.py

@@ -1,2 +0,0 @@
-{*42}
-# Raise=TypeError("'int' object is not iterable")

package/ref-monty/crates/monty/test_cases/slice__invalid_indices.py

@@ -1,2 +0,0 @@
-[1, 2, 3]['a':'b']
-# Raise=TypeError('slice indices must be integers or None or have an __index__ method')

package/ref-monty/crates/monty/test_cases/slice__kwargs.py

@@ -1,9 +0,0 @@
-slice(stop=5)
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "slice__kwargs.py", line 1, in <module>
-    slice(stop=5)
-    ~~~~~~~~~~~~~
-TypeError: slice() takes no keyword arguments
-"""

package/ref-monty/crates/monty/test_cases/slice__no_args.py

@@ -1,9 +0,0 @@
-slice()
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "slice__no_args.py", line 1, in <module>
-    slice()
-    ~~~~~~~
-TypeError: slice expected at least 1 argument, got 0
-"""

package/ref-monty/crates/monty/test_cases/slice__ops.py

@@ -1,149 +0,0 @@
-# === Basic list slicing ===
-lst = [0, 1, 2, 3, 4, 5]
-assert lst[1:4] == [1, 2, 3], 'basic list slice'
-assert lst[:3] == [0, 1, 2], 'list slice from start'
-assert lst[3:] == [3, 4, 5], 'list slice to end'
-assert lst[:] == [0, 1, 2, 3, 4, 5], 'list full slice'
-
-# === Negative indices ===
-assert lst[-3:] == [3, 4, 5], 'list slice negative start'
-assert lst[:-2] == [0, 1, 2, 3], 'list slice negative stop'
-assert lst[-4:-1] == [2, 3, 4], 'list slice both negative'
-
-# === Step ===
-assert lst[::2] == [0, 2, 4], 'list slice with step'
-assert lst[1::2] == [1, 3, 5], 'list slice with start and step'
-assert lst[::-1] == [5, 4, 3, 2, 1, 0], 'list reverse slice'
-assert lst[4:1:-1] == [4, 3, 2], 'list negative step with bounds'
-assert lst[::3] == [0, 3], 'list slice step of 3'
-
-# === Out of bounds (clamped) ===
-assert lst[10:20] == [], 'list out of bounds high'
-assert lst[-100:2] == [0, 1], 'list out of bounds low'
-assert lst[2:100] == [2, 3, 4, 5], 'list stop beyond length'
-
-# === Empty results ===
-assert lst[3:1] == [], 'list empty slice start > stop'
-assert lst[3:3] == [], 'list empty slice start == stop'
-
-# === String slicing ===
-s = 'hello'
-assert s[1:4] == 'ell', 'string slice basic'
-assert s[:3] == 'hel', 'string slice from start'
-assert s[3:] == 'lo', 'string slice to end'
-assert s[:] == 'hello', 'string full slice'
-assert s[::-1] == 'olleh', 'string reverse'
-assert s[::2] == 'hlo', 'string slice with step'
-
-# === Unicode string slicing ===
-u = 'cafe'
-assert u[1:3] == 'af', 'unicode slice basic'
-assert u[::-1] == 'efac', 'unicode reverse'
-
-# === Tuple slicing ===
-t = (0, 1, 2, 3, 4)
-assert t[1:4] == (1, 2, 3), 'tuple slice basic'
-assert t[::-1] == (4, 3, 2, 1, 0), 'tuple reverse'
-assert t[::2] == (0, 2, 4), 'tuple slice with step'
-
-# === Bytes slicing ===
-b = b'\x00\x01\x02\x03\x04'
-assert b[1:4] == b'\x01\x02\x03', 'bytes slice basic'
-assert b[::-1] == b'\x04\x03\x02\x01\x00', 'bytes reverse'
-assert b[::2] == b'\x00\x02\x04', 'bytes slice with step'
-
-# === Range slicing ===
-r = range(10)
-assert r[2:5] == range(2, 5), 'range slice basic'
-assert r[::2] == range(0, 10, 2), 'range slice with step'
-
-r2 = range(0, 10, 2)
-assert r2[1:4] == range(2, 8, 2), 'stepped range slice'
-
-# === slice() builtin ===
-s1 = slice(3)
-assert s1.start is None, 'slice stop only - start is None'
-assert s1.stop == 3, 'slice stop only - stop is 3'
-assert s1.step is None, 'slice stop only - step is None'
-
-s2 = slice(1, 4)
-assert s2.start == 1, 'slice start stop - start is 1'
-assert s2.stop == 4, 'slice start stop - stop is 4'
-assert s2.step is None, 'slice start stop - step is None'
-
-s3 = slice(1, 10, 2)
-assert s3.start == 1, 'slice full - start is 1'
-assert s3.stop == 10, 'slice full - stop is 10'
-assert s3.step == 2, 'slice full - step is 2'
-
-# === Using slice objects ===
-sl = slice(1, 4)
-assert lst[sl] == [1, 2, 3], 'slice object for list'
-assert s[sl] == 'ell', 'slice object for string'
-assert t[sl] == (1, 2, 3), 'slice object for tuple'
-
-# === slice repr and str ===
-assert repr(slice(3)) == 'slice(None, 3, None)', 'slice repr stop only'
-assert repr(slice(1, 4)) == 'slice(1, 4, None)', 'slice repr start stop'
-assert repr(slice(1, 10, 2)) == 'slice(1, 10, 2)', 'slice repr full'
-assert str(slice(1, 4)) == 'slice(1, 4, None)', 'slice str same as repr'
-
-# === Edge case: negative step with None bounds ===
-assert lst[::-2] == [5, 3, 1], 'list negative step no bounds'
-assert s[::-2] == 'olh', 'string negative step no bounds'
-
-# === Edge case: step larger than length ===
-assert lst[::10] == [0], 'step larger than length'
-
-# === Empty sequence slicing ===
-empty_list = []
-assert empty_list[:] == [], 'empty list full slice'
-assert empty_list[1:4] == [], 'empty list any slice'
-assert empty_list[::-1] == [], 'empty list reverse'
-
-empty_str = ''
-assert empty_str[:] == '', 'empty string full slice'
-assert empty_str[1:4] == '', 'empty string any slice'
-
-# === Boolean truthiness of slice ===
-assert slice(1, 2), 'slice is truthy'
-assert slice(None), 'slice with None stop is truthy'
-
-# === Slice equality ===
-assert slice(1, 2) == slice(1, 2), 'slice equality same values'
-assert not (slice(1, 2) == slice(1, 3)), 'slice inequality different stop'
-assert slice(None) == slice(None), 'slice equality both None'
-assert slice(1, 2, 3) == slice(1, 2, 3), 'slice equality with step'
-assert not (slice(1, 2, 3) == slice(1, 2, 4)), 'slice inequality different step'
-
-# === Slice with bool indices ===
-assert [0, 1, 2, 3][True:] == [1, 2, 3], 'slice with True start'
-assert [0, 1, 2, 3][:True] == [0], 'slice with True stop'
-assert [0, 1, 2, 3][::True] == [0, 1, 2, 3], 'slice with True step'
-assert [0, 1, 2, 3][False:] == [0, 1, 2, 3], 'slice with False start'
-assert [0, 1, 2, 3][:False] == [], 'slice with False stop'
-
-# === Range slicing edge cases ===
-assert range(0)[1:2] == range(0, 0), 'empty range slicing'
-assert range(5)[::-1] == range(4, -1, -1), 'range reverse slice'
-assert list(range(5)[::-1]) == [4, 3, 2, 1, 0], 'range reverse slice iteration'
-
-# === Negative step with out-of-bounds start ===
-lst5 = [0, 1, 2, 3, 4]
-assert lst5[-10::-1] == [], 'far negative start with negative step should be empty'
-assert lst5[-6::-1] == [], 'just out of bounds negative start'
-assert lst5[-5::-1] == [0], 'exactly at first element'
-assert lst5[-4::-1] == [1, 0], 'second element backwards'
-
-# Range slicing with out-of-bounds negative start
-assert list(range(5)[-10::-1]) == [], 'range far negative start'
-assert list(range(5)[-6::-1]) == [], 'range just out of bounds'
-assert list(range(5)[-5::-1]) == [0], 'range exactly at first'
-
-# String slicing with out-of-bounds negative start
-assert 'hello'[-10::-1] == '', 'string far negative start empty'
-assert 'hello'[-5::-1] == 'h', 'string exactly at first'
-
-# Tuple slicing with out-of-bounds negative start
-assert (0, 1, 2, 3, 4)[-10::-1] == (), 'tuple far negative start empty'
-assert (0, 1, 2, 3, 4)[-5::-1] == (0,), 'tuple exactly at first'

package/ref-monty/crates/monty/test_cases/slice__step_zero.py

@@ -1,9 +0,0 @@
-[1, 2, 3][::0]
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "slice__step_zero.py", line 1, in <module>
-    [1, 2, 3][::0]
-    ~~~~~~~~~~~~~~
-ValueError: slice step cannot be zero
-"""

package/ref-monty/crates/monty/test_cases/slice__step_zero_bytes.py

@@ -1,9 +0,0 @@
-b'hello'[::0]
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "slice__step_zero_bytes.py", line 1, in <module>
-    b'hello'[::0]
-    ~~~~~~~~~~~~~
-ValueError: slice step cannot be zero
-"""

package/ref-monty/crates/monty/test_cases/slice__step_zero_range.py

@@ -1,9 +0,0 @@
-range(5)[::0]
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "slice__step_zero_range.py", line 1, in <module>
-    range(5)[::0]
-    ~~~~~~~~~~~~~
-ValueError: slice step cannot be zero
-"""

package/ref-monty/crates/monty/test_cases/slice__step_zero_str.py

@@ -1,9 +0,0 @@
-'hello'[::0]
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "slice__step_zero_str.py", line 1, in <module>
-    'hello'[::0]
-    ~~~~~~~~~~~~
-ValueError: slice step cannot be zero
-"""

package/ref-monty/crates/monty/test_cases/slice__step_zero_tuple.py

@@ -1,9 +0,0 @@
-(1, 2, 3)[::0]
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "slice__step_zero_tuple.py", line 1, in <module>
-    (1, 2, 3)[::0]
-    ~~~~~~~~~~~~~~
-ValueError: slice step cannot be zero
-"""