superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,27 @@
+# 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

@@ -0,0 +1,6 @@
+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

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

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,5 @@
+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

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

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,37 @@
+# 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

@@ -0,0 +1,34 @@
+# 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

@@ -0,0 +1,31 @@
+# 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

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

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

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

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

@@ -0,0 +1,24 @@
+# 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

@@ -0,0 +1,191 @@
+# === 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

@@ -0,0 +1,35 @@
+# 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

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

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

@@ -0,0 +1,2 @@
+[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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,149 @@
+# === 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

@@ -0,0 +1,9 @@
+[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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,9 @@
+'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

@@ -0,0 +1,9 @@
+(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
+"""