superacli 1.1.6 → 1.1.8

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

@@ -1,394 +0,0 @@
-# === bytes.decode() ===
-assert b'hello'.decode() == 'hello', 'decode default utf-8'
-assert b'hello'.decode('utf-8') == 'hello', 'decode explicit utf-8'
-assert b'hello'.decode('utf8') == 'hello', 'decode utf8 variant'
-assert b'hello'.decode('UTF-8') == 'hello', 'decode uppercase UTF-8'
-assert b''.decode() == '', 'decode empty bytes'
-
-# Non-ASCII UTF-8
-assert b'\xc3\xa9'.decode() == '\xe9', 'decode utf-8 e-acute'
-assert b'\xe4\xb8\xad'.decode() == '\u4e2d', 'decode utf-8 CJK character'
-
-# === bytes.count() ===
-assert b'hello'.count(b'l') == 2, 'count single char'
-assert b'hello'.count(b'll') == 1, 'count subsequence'
-assert b'hello'.count(b'x') == 0, 'count not found'
-assert b'aaa'.count(b'aa') == 1, 'count non-overlapping'
-assert b''.count(b'x') == 0, 'count in empty bytes'
-assert b'hello'.count(b'') == 6, 'count empty subsequence'
-
-# count with start/end
-assert b'abcabc'.count(b'ab', 1) == 1, 'count with start'
-assert b'abcabc'.count(b'ab', 0, 3) == 1, 'count with start and end'
-
-# === bytes.find() ===
-assert b'hello'.find(b'e') == 1, 'find single char'
-assert b'hello'.find(b'll') == 2, 'find subsequence'
-assert b'hello'.find(b'x') == -1, 'find not found'
-assert b'hello'.find(b'') == 0, 'find empty subsequence'
-assert b''.find(b'x') == -1, 'find in empty bytes'
-
-# find with start/end
-assert b'hello'.find(b'l', 3) == 3, 'find with start'
-assert b'hello'.find(b'l', 0, 2) == -1, 'find with end before match'
-
-# === bytes.index() ===
-assert b'hello'.index(b'e') == 1, 'index single char'
-assert b'hello'.index(b'll') == 2, 'index subsequence'
-assert b'hello'.index(b'') == 0, 'index empty subsequence'
-
-# === bytes.startswith() ===
-assert b'hello'.startswith(b'he'), 'startswith true'
-assert not b'hello'.startswith(b'lo'), 'startswith false'
-assert b'hello'.startswith(b''), 'startswith empty'
-assert b''.startswith(b''), 'empty startswith empty'
-assert not b''.startswith(b'x'), 'empty startswith non-empty'
-
-# startswith with start/end
-assert b'abcdef'.startswith(b'bc', 1), 'startswith with start'
-assert b'abcdef'.startswith(b'bc', 1, 3), 'startswith with start and end'
-assert not b'abcdef'.startswith(b'bc', 2), 'startswith with start past match'
-assert not b'abcdef'.startswith(b'abc', 0, 2), 'startswith with end before match ends'
-
-# === bytes.endswith() ===
-assert b'hello'.endswith(b'lo'), 'endswith true'
-assert not b'hello'.endswith(b'he'), 'endswith false'
-assert b'hello'.endswith(b''), 'endswith empty'
-assert b''.endswith(b''), 'empty endswith empty'
-assert not b''.endswith(b'x'), 'empty endswith non-empty'
-
-# endswith with start/end
-assert b'abcdef'.endswith(b'de', 0, 5), 'endswith with end'
-assert b'abcdef'.endswith(b'cd', 1, 4), 'endswith with start and end'
-assert not b'abcdef'.endswith(b'de', 0, 4), 'endswith before suffix'
-
-# === Edge case: start > end (should not panic, treat as empty slice) ===
-assert b'hello'.find(b'e', 5, 2) == -1, 'find with start > end returns -1'
-assert b'hello'.count(b'l', 5, 2) == 0, 'count with start > end returns 0'
-assert not b'hello'.startswith(b'h', 5, 2), 'startswith with start > end is false'
-assert not b'hello'.endswith(b'o', 5, 2), 'endswith with start > end is false'
-
-# === bytes.lower() ===
-assert b'HELLO'.lower() == b'hello', 'lower basic'
-assert b'Hello World'.lower() == b'hello world', 'lower mixed case'
-assert b'hello'.lower() == b'hello', 'lower already lowercase'
-assert b''.lower() == b'', 'lower empty'
-assert b'123ABC'.lower() == b'123abc', 'lower with digits'
-assert b'\x80\xff'.lower() == b'\x80\xff', 'lower non-ascii unchanged'
-
-# === bytes.upper() ===
-assert b'hello'.upper() == b'HELLO', 'upper basic'
-assert b'Hello World'.upper() == b'HELLO WORLD', 'upper mixed case'
-assert b'HELLO'.upper() == b'HELLO', 'upper already uppercase'
-assert b''.upper() == b'', 'upper empty'
-assert b'123abc'.upper() == b'123ABC', 'upper with digits'
-
-# === bytes.capitalize() ===
-assert b'hello'.capitalize() == b'Hello', 'capitalize basic'
-assert b'HELLO'.capitalize() == b'Hello', 'capitalize uppercase'
-assert b'hELLO wORLD'.capitalize() == b'Hello world', 'capitalize mixed'
-assert b''.capitalize() == b'', 'capitalize empty'
-assert b'123hello'.capitalize() == b'123hello', 'capitalize starting with digit'
-
-# === bytes.title() ===
-assert b'hello world'.title() == b'Hello World', 'title basic'
-assert b'HELLO WORLD'.title() == b'Hello World', 'title uppercase'
-assert b"they're bill's".title() == b"They'Re Bill'S", 'title with apostrophe'
-assert b''.title() == b'', 'title empty'
-
-# === bytes.swapcase() ===
-assert b'Hello World'.swapcase() == b'hELLO wORLD', 'swapcase basic'
-assert b'HELLO'.swapcase() == b'hello', 'swapcase uppercase'
-assert b'hello'.swapcase() == b'HELLO', 'swapcase lowercase'
-assert b''.swapcase() == b'', 'swapcase empty'
-
-# === bytes.isalpha() ===
-assert b'hello'.isalpha(), 'isalpha all letters'
-assert not b'hello123'.isalpha(), 'isalpha with digits'
-assert not b'hello world'.isalpha(), 'isalpha with space'
-assert not b''.isalpha(), 'isalpha empty is false'
-assert b'ABC'.isalpha(), 'isalpha uppercase'
-
-# === bytes.isdigit() ===
-assert b'123'.isdigit(), 'isdigit all digits'
-assert not b'123abc'.isdigit(), 'isdigit with letters'
-assert not b''.isdigit(), 'isdigit empty is false'
-
-# === bytes.isalnum() ===
-assert b'hello123'.isalnum(), 'isalnum letters and digits'
-assert b'hello'.isalnum(), 'isalnum all letters'
-assert b'123'.isalnum(), 'isalnum all digits'
-assert not b'hello world'.isalnum(), 'isalnum with space'
-assert not b''.isalnum(), 'isalnum empty is false'
-
-# === bytes.isspace() ===
-assert b' \t\n\r'.isspace(), 'isspace whitespace chars'
-assert not b'hello'.isspace(), 'isspace not all whitespace'
-assert not b''.isspace(), 'isspace empty is false'
-assert b' '.isspace(), 'isspace single space'
-
-# === bytes.islower() ===
-assert b'hello'.islower(), 'islower all lowercase'
-assert b'hello123'.islower(), 'islower with digits'
-assert not b'Hello'.islower(), 'islower with uppercase'
-assert not b'HELLO'.islower(), 'islower all uppercase'
-assert not b''.islower(), 'islower empty is false'
-assert not b'123'.islower(), 'islower no cased chars is false'
-
-# === bytes.isupper() ===
-assert b'HELLO'.isupper(), 'isupper all uppercase'
-assert b'HELLO123'.isupper(), 'isupper with digits'
-assert not b'Hello'.isupper(), 'isupper with lowercase'
-assert not b'hello'.isupper(), 'isupper all lowercase'
-assert not b''.isupper(), 'isupper empty is false'
-assert not b'123'.isupper(), 'isupper no cased chars is false'
-
-# === bytes.isascii() ===
-assert b'hello'.isascii(), 'isascii all ascii'
-assert b''.isascii(), 'isascii empty is true'
-assert b'\x00\x7f'.isascii(), 'isascii boundary values'
-assert not b'\x80'.isascii(), 'isascii non-ascii byte'
-assert not b'hello\xff'.isascii(), 'isascii with non-ascii'
-
-# === bytes.istitle() ===
-assert b'Hello World'.istitle(), 'istitle basic'
-assert not b'hello world'.istitle(), 'istitle lowercase'
-assert not b'HELLO WORLD'.istitle(), 'istitle uppercase'
-assert b'Hello'.istitle(), 'istitle single word'
-assert not b''.istitle(), 'istitle empty is false'
-
-# === bytes.rfind() ===
-assert b'hello'.rfind(b'l') == 3, 'rfind finds last occurrence'
-assert b'hello'.rfind(b'x') == -1, 'rfind not found'
-assert b'hello'.rfind(b'') == 5, 'rfind empty at end'
-assert b'aaaa'.rfind(b'aa') == 2, 'rfind non-overlapping from right'
-assert b'hello'.rfind(b'l', 0, 3) == 2, 'rfind with range'
-
-# === bytes.rindex() ===
-assert b'hello'.rindex(b'l') == 3, 'rindex finds last occurrence'
-assert b'hello'.rindex(b'') == 5, 'rindex empty at end'
-
-# === bytes.strip() ===
-assert b'  hello  '.strip() == b'hello', 'strip whitespace'
-assert b'hello'.strip() == b'hello', 'strip no whitespace'
-assert b'xxxhelloxxx'.strip(b'x') == b'hello', 'strip custom chars'
-assert b''.strip() == b'', 'strip empty'
-assert b'   '.strip() == b'', 'strip all whitespace'
-
-# === bytes.lstrip() ===
-assert b'  hello  '.lstrip() == b'hello  ', 'lstrip whitespace'
-assert b'xxxhello'.lstrip(b'x') == b'hello', 'lstrip custom chars'
-assert b''.lstrip() == b'', 'lstrip empty'
-
-# === bytes.rstrip() ===
-assert b'  hello  '.rstrip() == b'  hello', 'rstrip whitespace'
-assert b'helloxxx'.rstrip(b'x') == b'hello', 'rstrip custom chars'
-assert b''.rstrip() == b'', 'rstrip empty'
-
-# === bytes.removeprefix() ===
-assert b'hello'.removeprefix(b'he') == b'llo', 'removeprefix found'
-assert b'hello'.removeprefix(b'xxx') == b'hello', 'removeprefix not found'
-assert b'hello'.removeprefix(b'') == b'hello', 'removeprefix empty'
-assert b''.removeprefix(b'x') == b'', 'removeprefix empty bytes'
-
-# === bytes.removesuffix() ===
-assert b'hello'.removesuffix(b'lo') == b'hel', 'removesuffix found'
-assert b'hello'.removesuffix(b'xxx') == b'hello', 'removesuffix not found'
-assert b'hello'.removesuffix(b'') == b'hello', 'removesuffix empty'
-assert b''.removesuffix(b'x') == b'', 'removesuffix empty bytes'
-
-# === bytes.split() ===
-assert b'a,b,c'.split(b',') == [b'a', b'b', b'c'], 'split basic'
-assert b'a b c'.split() == [b'a', b'b', b'c'], 'split whitespace'
-assert b'a  b  c'.split() == [b'a', b'b', b'c'], 'split multiple whitespace'
-assert b'a,b,c'.split(b',', 1) == [b'a', b'b,c'], 'split maxsplit'
-assert b''.split() == [], 'split empty bytes'
-assert b'hello'.split(b'x') == [b'hello'], 'split not found'
-
-# === bytes.rsplit() ===
-assert b'a,b,c'.rsplit(b',') == [b'a', b'b', b'c'], 'rsplit basic'
-assert b'a,b,c'.rsplit(b',', 1) == [b'a,b', b'c'], 'rsplit maxsplit'
-assert b'a b c'.rsplit() == [b'a', b'b', b'c'], 'rsplit whitespace'
-
-# === bytes.splitlines() ===
-assert b'a\nb\nc'.splitlines() == [b'a', b'b', b'c'], 'splitlines newline'
-assert b'a\r\nb\rc'.splitlines() == [b'a', b'b', b'c'], 'splitlines mixed'
-assert b'a\nb\n'.splitlines() == [b'a', b'b'], 'splitlines trailing'
-assert b'a\nb'.splitlines(True) == [b'a\n', b'b'], 'splitlines keepends'
-assert b''.splitlines() == [], 'splitlines empty'
-
-# === bytes.partition() ===
-assert b'hello world'.partition(b' ') == (b'hello', b' ', b'world'), 'partition found'
-assert b'hello'.partition(b'x') == (b'hello', b'', b''), 'partition not found'
-assert b'hello world here'.partition(b' ') == (b'hello', b' ', b'world here'), 'partition first'
-
-# === bytes.rpartition() ===
-assert b'hello world'.rpartition(b' ') == (b'hello', b' ', b'world'), 'rpartition found'
-assert b'hello'.rpartition(b'x') == (b'', b'', b'hello'), 'rpartition not found'
-assert b'hello world here'.rpartition(b' ') == (b'hello world', b' ', b'here'), 'rpartition last'
-
-# === bytes.replace() ===
-assert b'hello'.replace(b'l', b'L') == b'heLLo', 'replace all'
-assert b'hello'.replace(b'l', b'L', 1) == b'heLlo', 'replace count'
-assert b'hello'.replace(b'x', b'y') == b'hello', 'replace not found'
-assert b'aaa'.replace(b'a', b'bb') == b'bbbbbb', 'replace longer'
-assert b'aaa'.replace(b'aa', b'b') == b'ba', 'replace non-overlapping'
-
-# === bytes.center() ===
-assert b'hello'.center(10) == b'  hello   ', 'center basic'
-assert b'hello'.center(10, b'*') == b'**hello***', 'center fillbyte'
-assert b'hello'.center(3) == b'hello', 'center too short'
-
-# === bytes.ljust() ===
-assert b'hello'.ljust(10) == b'hello     ', 'ljust basic'
-assert b'hello'.ljust(10, b'*') == b'hello*****', 'ljust fillbyte'
-assert b'hello'.ljust(3) == b'hello', 'ljust too short'
-
-# === bytes.rjust() ===
-assert b'hello'.rjust(10) == b'     hello', 'rjust basic'
-assert b'hello'.rjust(10, b'*') == b'*****hello', 'rjust fillbyte'
-assert b'hello'.rjust(3) == b'hello', 'rjust too short'
-
-# === bytes.zfill() ===
-assert b'42'.zfill(5) == b'00042', 'zfill basic'
-assert b'-42'.zfill(5) == b'-0042', 'zfill negative'
-assert b'+42'.zfill(5) == b'+0042', 'zfill positive'
-assert b'hello'.zfill(3) == b'hello', 'zfill too short'
-
-# === bytes.join() ===
-assert b','.join([b'a', b'b', b'c']) == b'a,b,c', 'join list'
-assert b''.join([b'a', b'b']) == b'ab', 'join empty separator'
-assert b','.join([]) == b'', 'join empty iterable'
-assert b'-'.join([b'hello']) == b'hello', 'join single item'
-
-# === bytes.hex() ===
-assert b'\xde\xad\xbe\xef'.hex() == 'deadbeef', 'hex basic'
-assert b''.hex() == '', 'hex empty'
-assert b'AB'.hex() == '4142', 'hex letters'
-assert b'\x00\xff'.hex() == '00ff', 'hex boundary'
-assert b'\xde\xad\xbe\xef'.hex(':') == 'de:ad:be:ef', 'hex with separator'
-assert b'\xde\xad\xbe\xef'.hex(':', 2) == 'dead:beef', 'hex with bytes_per_sep'
-# Test positive bytes_per_sep (partial group at start)
-assert b'\x01\x02\x03\x04\x05'.hex(':', 2) == '01:0203:0405', 'hex +2 odd bytes'
-assert b'\x01\x02\x03'.hex(':', 2) == '01:0203', 'hex +2 three bytes'
-# Test negative bytes_per_sep (partial group at end)
-assert b'\x01\x02\x03\x04\x05'.hex(':', -2) == '0102:0304:05', 'hex -2 odd bytes'
-assert b'\x01\x02\x03'.hex(':', -2) == '0102:03', 'hex -2 three bytes'
-
-# === bytes.fromhex() ===
-assert bytes.fromhex('deadbeef') == b'\xde\xad\xbe\xef', 'fromhex basic'
-assert bytes.fromhex('DEADBEEF') == b'\xde\xad\xbe\xef', 'fromhex uppercase'
-assert bytes.fromhex('') == b'', 'fromhex empty'
-assert bytes.fromhex('de ad be ef') == b'\xde\xad\xbe\xef', 'fromhex with spaces'
-assert bytes.fromhex('4142') == b'AB', 'fromhex letters'
-
-# === bytes.fromhex() with whitespace ===
-# Whitespace is only allowed BETWEEN byte pairs, not within a pair
-assert bytes.fromhex(' 01 ') == b'\x01', 'fromhex whitespace around bytes is stripped'
-assert bytes.fromhex('01 23') == b'\x01\x23', 'fromhex whitespace between byte pairs'
-
-# === bytes.fromhex() errors ===
-# Odd number of hex digits (no invalid chars, just odd count)
-try:
-    bytes.fromhex('0')
-    assert False, 'fromhex odd digits should error'
-except ValueError as e:
-    assert str(e) == 'fromhex() arg must contain an even number of hexadecimal digits', (
-        f'fromhex odd digits message, error: {e}'
-    )
-
-try:
-    bytes.fromhex(' 0')
-    assert False, 'fromhex odd digits after whitespace should error'
-except ValueError as e:
-    assert str(e) == 'fromhex() arg must contain an even number of hexadecimal digits', (
-        f'fromhex odd digits after whitespace message, error: {e}'
-    )
-
-# Whitespace within a byte pair is invalid (space is not a hex digit)
-try:
-    bytes.fromhex('0 1')
-    assert False, 'fromhex whitespace within pair should error'
-except ValueError as e:
-    assert str(e) == 'non-hexadecimal number found in fromhex() arg at position 1', (
-        f'fromhex whitespace within pair message, error: {e}'
-    )
-
-# Invalid hex character
-try:
-    bytes.fromhex('0g')
-    assert False, 'fromhex invalid hex char should error'
-except ValueError as e:
-    assert str(e) == 'non-hexadecimal number found in fromhex() arg at position 1', (
-        f'fromhex invalid hex char message, error: {e}'
-    )
-
-# === bytes.fromhex() instance access ===
-# fromhex is a classmethod but should also work on instances
-assert b''.fromhex('4142') == b'AB', 'fromhex on bytes instance'
-assert b'hello'.fromhex('deadbeef') == b'\xde\xad\xbe\xef', 'fromhex on non-empty instance'
-
-# === bytes.startswith/endswith with tuple of prefixes ===
-assert b'hello'.startswith((b'he', b'wo')), 'startswith tuple first match'
-assert b'hello'.startswith((b'wo', b'he')), 'startswith tuple second match'
-assert not b'hello'.startswith((b'wo', b'ab')), 'startswith tuple no match'
-assert b'hello'.startswith((b'',)), 'startswith tuple with empty bytes'
-assert b'hello'.startswith((b'hello', b'world')), 'startswith tuple exact match'
-
-assert b'hello'.endswith((b'lo', b'ld')), 'endswith tuple first match'
-assert b'hello'.endswith((b'ld', b'lo')), 'endswith tuple second match'
-assert not b'hello'.endswith((b'he', b'ab')), 'endswith tuple no match'
-assert b'hello'.endswith((b'',)), 'endswith tuple with empty bytes'
-assert b'hello'.endswith((b'hello', b'world')), 'endswith tuple exact match'
-
-# startswith/endswith tuple with start/end
-assert b'abcdef'.startswith((b'bc', b'cd'), 1), 'startswith tuple with start'
-assert b'abcdef'.endswith((b'de', b'cd'), 0, 5), 'endswith tuple with end'
-
-# === Empty-substring edge cases ===
-# Edge case: start == len (boundary) - this works
-assert b'hello'.find(b'', 5) == 5, 'find empty at len returns len'
-assert b'hello'.count(b'', 5) == 1, 'count empty at len returns 1'
-assert b'hello'.startswith(b'', 5), 'startswith empty at len is true'
-assert b'hello'.endswith(b'', 5), 'endswith empty at len is true'
-
-# TODO: These edge cases when start > len need to be fixed
-# CPython returns -1/0/False for these, currently Monty doesn't handle this correctly
-# assert b'hello'.find(b'', 10) == -1, 'find empty when start > len returns -1'
-# assert b'hello'.count(b'', 10) == 0, 'count empty when start > len returns 0'
-# assert not b'hello'.startswith(b'', 10), 'startswith empty when start > len is false'
-# assert not b'hello'.endswith(b'', 10), 'endswith empty when start > len is false'
-# assert b'hello'.rfind(b'', 10) == -1, 'rfind empty when start > len returns -1'
-
-# === bytes.hex() non-ASCII separator errors ===
-try:
-    b'\x01\x02'.hex('\xff')
-    assert False, 'hex with non-ASCII separator should error'
-except ValueError as e:
-    # CPython uses 'sep must be ASCII.' with period
-    msg = str(e)
-    assert 'sep' in msg.lower() and 'ascii' in msg.lower(), f'hex non-ASCII sep message, error: {e}'
-
-# === bytes.decode() with errors argument ===
-# Valid errors values
-assert b'hello'.decode('utf-8', 'strict') == 'hello', 'decode with strict errors'
-assert b'hello'.decode('utf-8', 'ignore') == 'hello', 'decode with ignore errors'
-assert b'hello'.decode('utf-8', 'replace') == 'hello', 'decode with replace errors'
-
-# TODO: errors argument type validation - CPython raises TypeError for non-string errors
-# This is not implemented yet
-# try:
-#     b'hello'.decode('utf-8', 123)
-#     assert False, 'decode with non-string errors should error'
-# except TypeError as e:
-#     assert 'str' in str(e), f'decode errors type error should mention str, error: {e}'
-
-# === Error message for unknown classmethod ===
-# Error message should say 'bytes' not 'type'
-try:
-    bytes.nonexistent()
-    assert False, 'should raise AttributeError'
-except AttributeError as e:
-    msg = str(e)
-    assert 'bytes' in msg, f'error should mention bytes, got: {e}'
-    assert 'nonexistent' in msg, f'error should mention method name, got: {e}'

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

@@ -1,9 +0,0 @@
-bytes(-1)
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "bytes__negative_count.py", line 1, in <module>
-    bytes(-1)
-    ~~~~~~~~~
-ValueError: negative count
-"""

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

@@ -1,90 +0,0 @@
-# === Bytes length ===
-assert len(b'') == 0, 'len empty'
-assert len(b'hello') == 5, 'len basic'
-
-# === Bytes repr/str ===
-assert repr(b'hello') == "b'hello'", 'bytes repr'
-assert str(b'hello') == "b'hello'", 'bytes str'
-
-# === Various bytes repr cases ===
-assert repr(b'') == "b''", 'empty bytes repr'
-assert repr(b"it's") == 'b"it\'s"', 'single quote bytes repr'
-assert repr(b'l1\nl2') == "b'l1\\nl2'", 'newline bytes repr'
-assert repr(b'col1\tcol2') == "b'col1\\tcol2'", 'tab bytes repr'
-assert repr(b'\x00\xff') == "b'\\x00\\xff'", 'non-printable bytes repr'
-assert repr(b'back\\slash') == "b'back\\\\slash'", 'backslash bytes repr'
-
-# === Bytes repetition (*) ===
-assert b'ab' * 3 == b'ababab', 'bytes mult int'
-assert 3 * b'ab' == b'ababab', 'int mult bytes'
-assert b'x' * 0 == b'', 'bytes mult zero'
-assert b'x' * -1 == b'', 'bytes mult negative'
-assert b'' * 5 == b'', 'empty bytes mult'
-assert b'ab' * 1 == b'ab', 'bytes mult one'
-
-# === Bytes indexing (getitem) ===
-# Basic indexing - returns integer byte values
-assert b'hello'[0] == 104, 'bytes getitem index 0 (h=104)'
-assert b'hello'[1] == 101, 'bytes getitem index 1 (e=101)'
-assert b'hello'[4] == 111, 'bytes getitem last index (o=111)'
-
-# Negative indexing
-assert b'hello'[-1] == 111, 'bytes getitem -1 (o=111)'
-assert b'hello'[-2] == 108, 'bytes getitem -2 (l=108)'
-assert b'hello'[-5] == 104, 'bytes getitem -5 (h=104)'
-
-# Single byte
-assert b'x'[0] == 120, 'bytes getitem single byte at 0'
-assert b'x'[-1] == 120, 'bytes getitem single byte at -1'
-
-# ASCII printable range
-assert b' '[0] == 32, 'bytes getitem space (32)'
-assert b'~'[0] == 126, 'bytes getitem tilde (126)'
-
-# Non-printable bytes
-assert b'\x00'[0] == 0, 'bytes getitem null byte'
-assert b'\xff'[0] == 255, 'bytes getitem 0xff'
-assert b'\n'[0] == 10, 'bytes getitem newline'
-assert b'\t'[0] == 9, 'bytes getitem tab'
-
-# Heap-allocated bytes
-b = bytes(b'abc')
-assert b[0] == 97, 'heap bytes getitem 0'
-assert b[1] == 98, 'heap bytes getitem 1'
-assert b[-1] == 99, 'heap bytes negative getitem'
-
-# Variable index
-b = b'xyz'
-i = 1
-assert b[i] == 121, 'bytes getitem with variable index'
-
-# Verify return type is int
-val = b'A'[0]
-assert type(val) == int, 'bytes getitem returns int'
-assert val == 65, 'bytes getitem value is correct'
-
-# Bool indices (True=1, False=0)
-b = b'abc'
-assert b[False] == 97, 'bytes getitem with False'
-assert b[True] == 98, 'bytes getitem with True'
-
-# === Bytes comparisons ===
-assert b'abc' < b'abd', 'bytes < bytes'
-assert b'abd' > b'abc', 'bytes > bytes'
-assert b'abc' <= b'abc', 'bytes <= bytes equal'
-assert b'abc' <= b'abd', 'bytes <= bytes less'
-assert b'abd' >= b'abd', 'bytes >= bytes equal'
-assert b'abd' >= b'abc', 'bytes >= bytes greater'
-
-# Different lengths
-assert b'ab' < b'abc', 'shorter prefix is less'
-assert b'' < b'a', 'empty bytes is less'
-assert b'abc' > b'ab', 'longer bytes with same prefix is greater'
-
-# Non-ASCII byte values
-assert b'\x00' < b'\xff', 'null byte < 0xff'
-assert b'\xfe' < b'\xff', '0xfe < 0xff'
-
-# Sorting
-assert sorted([b'c', b'a', b'b']) == [b'a', b'b', b'c'], 'sorted bytes list'
-assert sorted([b'bb', b'a', b'ba']) == [b'a', b'ba', b'bb'], 'sorted different length bytes'

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

@@ -1,10 +0,0 @@
-# Test that bytes.startswith with str raises TypeError
-b'hello'.startswith('h')
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "bytes__startswith_str_error.py", line 2, in <module>
-    b'hello'.startswith('h')
-    ~~~~~~~~~~~~~~~~~~~~~~~~
-TypeError: startswith first arg must be bytes or a tuple of bytes, not str
-"""

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

@@ -1,3 +0,0 @@
-x = len
-x('abc')
-# Return=3

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

@@ -1,79 +0,0 @@
-# === Basic chain comparisons ===
-assert (1 < 2 < 3) == True, 'ascending chain'
-assert (1 < 3 < 2) == False, 'fails at second comparison'
-assert (3 < 2 < 1) == False, 'fails at first comparison'
-assert (1 <= 2 <= 2) == True, 'with equality'
-assert 1 <= 2 <= 2, 'with equality'
-assert 1 <= 2 <= 2 <= 3, 'chained with equality'
-
-# === Mixed operators ===
-assert (1 < 2 <= 2 < 3) == True, 'mixed lt and le'
-assert (1 == 1 == 1) == True, 'triple equality'
-assert (1 != 2 != 1) == True, 'not-equal chain (not transitive)'
-
-# === Longer chains ===
-assert (1 < 2 < 3 < 4 < 5) == True, '5-way ascending'
-assert (1 < 2 < 3 < 2 < 5) == False, 'fails in middle'
-
-# === With variables and expressions ===
-x = 5
-assert (1 < x < 10) == True, 'variable in chain'
-assert (0 < x - 3 < x < x + 1) == True, 'expressions'
-
-
-# === Short-circuit evaluation ===
-def test_short_circuit():
-    calls = []
-
-    def a():
-        calls.append('a')
-        return 1
-
-    def b():
-        calls.append('b')
-        return 0  # This will make first comparison fail
-
-    def c():
-        calls.append('c')
-        return 2
-
-    # Test: first comparison fails, c() should not be called
-    result = a() < b() < c()  # 1 < 0 is False, c() should not be called
-    assert result == False, 'short circuit result'
-    assert calls == ['a', 'b'], 'c not called due to short circuit'
-
-
-test_short_circuit()
-
-
-# === Single evaluation of intermediate values ===
-def test_single_eval():
-    count = 0
-
-    def middle():
-        nonlocal count
-        count += 1
-        return 5
-
-    result = 1 < middle() < 10
-    assert result == True, 'chain result'
-    assert count == 1, 'middle() called exactly once'
-
-
-test_single_eval()
-
-# === Identity comparisons ===
-a = [1]
-b = a
-c = a
-assert (a is b is c) == True, 'is chain same object'
-
-# === Containment checks ===
-assert (1 in [1, 2] in [[1, 2], [3]]) == True, 'in chain'
-
-
-# === Verify no namespace pollution ===
-# Note: The old implementation used _chain_cmp_N variables which would leak.
-# The new stack-based implementation doesn't create any intermediate variables.
-# We can't easily test for namespace pollution without dir(), so we just verify
-# that chain comparisons work correctly (covered by tests above).

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

@@ -1,81 +0,0 @@
-# === Parameter shadows outer local (basic) ===
-def outer_basic():
-    x = 42
-
-    def inner(x):
-        return x + 1
-
-    return inner(10)
-
-
-assert outer_basic() == 11, 'inner param should shadow outer local'
-
-
-# === Parameter shadows outer local (multiple params) ===
-def outer_multi():
-    a = 100
-    b = 200
-
-    def inner(a, b):
-        return a + b
-
-    return inner(1, 2)
-
-
-assert outer_multi() == 3, 'both params should shadow outer locals'
-
-
-# === Mixed: one param shadows, one captures ===
-def outer_mixed():
-    x = 10
-    y = 20
-
-    def inner(x):
-        return x + y
-
-    return inner(5)
-
-
-assert outer_mixed() == 25, 'x should be param (5), y should be captured (20)'
-
-
-# === Parameter shadows with default value ===
-def outer_default():
-    x = 99
-
-    def inner(x=7):
-        return x
-
-    return inner()
-
-
-assert outer_default() == 7, 'default param should shadow outer local'
-
-
-# === Deeply nested: param shadows grandparent local ===
-def outer_deep():
-    x = 1000
-
-    def middle():
-        def inner(x):
-            return x * 2
-
-        return inner(3)
-
-    return middle()
-
-
-assert outer_deep() == 6, 'inner param should shadow grandparent local'
-
-
-# === Parameter used in complex expression ===
-def outer_expr():
-    scale = 100
-
-    def inner(n, scale):
-        return n * scale + 1
-
-    return inner(5, 10)
-
-
-assert outer_expr() == 51, 'scale param should shadow outer scale'