superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,9 @@
+slice(1, 2, 3, 4)
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "slice__too_many_args.py", line 1, in <module>
+    slice(1, 2, 3, 4)
+    ~~~~~~~~~~~~~~~~~
+TypeError: slice expected at most 3 arguments, got 4
+"""

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

@@ -0,0 +1,10 @@
+s = 'hello'
+s[10]
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "str__getitem_index_error.py", line 2, in <module>
+    s[10]
+    ~~~~~
+IndexError: string index out of range
+"""

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

@@ -0,0 +1,9 @@
+'hello'.index('x')
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "str__index_not_found.py", line 1, in <module>
+    'hello'.index('x')
+    ~~~~~~~~~~~~~~~~~~
+ValueError: substring not found
+"""

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

@@ -0,0 +1,9 @@
+','.join()
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "str__join_no_args.py", line 1, in <module>
+    ','.join()
+    ~~~~~~~~~~
+TypeError: str.join() takes exactly one argument (0 given)
+"""

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

@@ -0,0 +1,9 @@
+','.join([1, 2])
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "str__join_non_string.py", line 1, in <module>
+    ','.join([1, 2])
+    ~~~~~~~~~~~~~~~~
+TypeError: sequence item 0: expected str instance, int found
+"""

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

@@ -0,0 +1,9 @@
+','.join(123)
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "str__join_not_iterable.py", line 1, in <module>
+    ','.join(123)
+    ~~~~~~~~~~~~~
+TypeError: can only join an iterable
+"""

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

@@ -0,0 +1,9 @@
+','.join(['a'], ['b'])
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "str__join_too_many_args.py", line 1, in <module>
+    ','.join(['a'], ['b'])
+    ~~~~~~~~~~~~~~~~~~~~~~
+TypeError: str.join() takes exactly one argument (2 given)
+"""

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

@@ -0,0 +1,327 @@
+# === Phase 1: Simple transformations ===
+
+# lower()
+assert 'HELLO'.lower() == 'hello', 'lower basic'
+assert 'Hello World'.lower() == 'hello world', 'lower mixed'
+assert 'hello'.lower() == 'hello', 'lower already lower'
+assert ''.lower() == '', 'lower empty'
+assert '123'.lower() == '123', 'lower numbers unchanged'
+
+# upper()
+assert 'hello'.upper() == 'HELLO', 'upper basic'
+assert 'Hello World'.upper() == 'HELLO WORLD', 'upper mixed'
+assert 'HELLO'.upper() == 'HELLO', 'upper already upper'
+assert ''.upper() == '', 'upper empty'
+assert '123'.upper() == '123', 'upper numbers unchanged'
+
+# capitalize()
+assert 'hello'.capitalize() == 'Hello', 'capitalize basic'
+assert 'HELLO'.capitalize() == 'Hello', 'capitalize all upper'
+assert 'hELLO wORLD'.capitalize() == 'Hello world', 'capitalize mixed'
+assert ''.capitalize() == '', 'capitalize empty'
+assert '123abc'.capitalize() == '123abc', 'capitalize number start'
+
+# title()
+assert 'hello world'.title() == 'Hello World', 'title basic'
+assert 'HELLO WORLD'.title() == 'Hello World', 'title all upper'
+assert "they're".title() == "They'Re", 'title apostrophe'
+assert ''.title() == '', 'title empty'
+assert '123 abc'.title() == '123 Abc', 'title number start'
+
+# swapcase()
+assert 'Hello World'.swapcase() == 'hELLO wORLD', 'swapcase basic'
+assert 'HELLO'.swapcase() == 'hello', 'swapcase all upper'
+assert 'hello'.swapcase() == 'HELLO', 'swapcase all lower'
+assert ''.swapcase() == '', 'swapcase empty'
+
+# casefold()
+assert 'Hello'.casefold() == 'hello', 'casefold basic'
+assert 'HELLO'.casefold() == 'hello', 'casefold all upper'
+assert ''.casefold() == '', 'casefold empty'
+
+# === Phase 2: Predicate methods ===
+
+# isalpha()
+assert 'hello'.isalpha() == True, 'isalpha basic'
+assert 'Hello'.isalpha() == True, 'isalpha mixed case'
+assert ''.isalpha() == False, 'isalpha empty'
+assert 'hello123'.isalpha() == False, 'isalpha with digits'
+assert 'hello world'.isalpha() == False, 'isalpha with space'
+
+# isdigit()
+assert '123'.isdigit() == True, 'isdigit basic'
+assert ''.isdigit() == False, 'isdigit empty'
+assert '123abc'.isdigit() == False, 'isdigit with letters'
+assert '12 34'.isdigit() == False, 'isdigit with space'
+
+# isalnum()
+assert 'hello123'.isalnum() == True, 'isalnum basic'
+assert 'hello'.isalnum() == True, 'isalnum letters only'
+assert '123'.isalnum() == True, 'isalnum digits only'
+assert ''.isalnum() == False, 'isalnum empty'
+assert 'hello 123'.isalnum() == False, 'isalnum with space'
+
+# isnumeric()
+assert '123'.isnumeric() == True, 'isnumeric basic'
+assert ''.isnumeric() == False, 'isnumeric empty'
+assert '123abc'.isnumeric() == False, 'isnumeric with letters'
+
+# isspace()
+assert '   '.isspace() == True, 'isspace spaces'
+assert '\t\n'.isspace() == True, 'isspace tabs and newlines'
+assert ''.isspace() == False, 'isspace empty'
+assert ' a '.isspace() == False, 'isspace with letter'
+
+# islower()
+assert 'hello'.islower() == True, 'islower basic'
+assert 'Hello'.islower() == False, 'islower mixed'
+assert ''.islower() == False, 'islower empty'
+assert '123'.islower() == False, 'islower numbers only'
+assert 'hello123'.islower() == True, 'islower with numbers'
+
+# isupper()
+assert 'HELLO'.isupper() == True, 'isupper basic'
+assert 'Hello'.isupper() == False, 'isupper mixed'
+assert ''.isupper() == False, 'isupper empty'
+assert '123'.isupper() == False, 'isupper numbers only'
+assert 'HELLO123'.isupper() == True, 'isupper with numbers'
+
+# isascii()
+assert 'hello'.isascii() == True, 'isascii basic'
+assert ''.isascii() == True, 'isascii empty'
+assert '\x00\x7f'.isascii() == True, 'isascii boundary'
+
+# isdecimal()
+assert '123'.isdecimal() == True, 'isdecimal basic'
+assert ''.isdecimal() == False, 'isdecimal empty'
+assert '123abc'.isdecimal() == False, 'isdecimal with letters'
+
+# === Phase 3: Search methods ===
+
+# find()
+assert 'hello'.find('l') == 2, 'find basic'
+assert 'hello'.find('ll') == 2, 'find substring'
+assert 'hello'.find('x') == -1, 'find not found'
+assert 'hello'.find('') == 0, 'find empty string'
+assert 'hello'.find('l', 3) == 3, 'find with start'
+assert 'hello'.find('l', 0, 3) == 2, 'find with start and end'
+
+# rfind()
+assert 'hello'.rfind('l') == 3, 'rfind basic'
+assert 'hello'.rfind('x') == -1, 'rfind not found'
+assert 'hello'.rfind('l', 0, 3) == 2, 'rfind with end'
+
+# index()
+assert 'hello'.index('l') == 2, 'index basic'
+assert 'hello'.index('ll') == 2, 'index substring'
+
+# rindex()
+assert 'hello'.rindex('l') == 3, 'rindex basic'
+
+# count()
+assert 'hello'.count('l') == 2, 'count basic'
+assert 'hello'.count('ll') == 1, 'count substring'
+assert 'hello'.count('x') == 0, 'count not found'
+assert 'hello'.count('') == 6, 'count empty string'
+assert 'aaa'.count('a') == 3, 'count repeated'
+
+# startswith()
+assert 'hello'.startswith('he') == True, 'startswith basic'
+assert 'hello'.startswith('lo') == False, 'startswith false'
+assert 'hello'.startswith('') == True, 'startswith empty'
+assert 'hello'.startswith('ell', 1) == True, 'startswith with start'
+
+# endswith()
+assert 'hello'.endswith('lo') == True, 'endswith basic'
+assert 'hello'.endswith('he') == False, 'endswith false'
+assert 'hello'.endswith('') == True, 'endswith empty'
+assert 'hello'.endswith('ell', 0, 4) == True, 'endswith with end'
+
+# === Phase 4: Strip/trim methods ===
+
+# strip()
+assert '  hello  '.strip() == 'hello', 'strip whitespace'
+assert 'xxhelloxx'.strip('x') == 'hello', 'strip chars'
+assert 'hello'.strip() == 'hello', 'strip nothing'
+assert ''.strip() == '', 'strip empty'
+assert '   '.strip() == '', 'strip only whitespace'
+
+# lstrip()
+assert '  hello  '.lstrip() == 'hello  ', 'lstrip whitespace'
+assert 'xxhello'.lstrip('x') == 'hello', 'lstrip chars'
+assert 'hello'.lstrip() == 'hello', 'lstrip nothing'
+
+# rstrip()
+assert '  hello  '.rstrip() == '  hello', 'rstrip whitespace'
+assert 'helloxx'.rstrip('x') == 'hello', 'rstrip chars'
+assert 'hello'.rstrip() == 'hello', 'rstrip nothing'
+
+# removeprefix()
+assert 'hello world'.removeprefix('hello ') == 'world', 'removeprefix basic'
+assert 'hello world'.removeprefix('world') == 'hello world', 'removeprefix not found'
+assert 'hello'.removeprefix('') == 'hello', 'removeprefix empty'
+
+# removesuffix()
+assert 'hello world'.removesuffix(' world') == 'hello', 'removesuffix basic'
+assert 'hello world'.removesuffix('hello') == 'hello world', 'removesuffix not found'
+assert 'hello'.removesuffix('') == 'hello', 'removesuffix empty'
+
+# === Phase 5: Split methods ===
+
+# split()
+assert 'a b c'.split() == ['a', 'b', 'c'], 'split whitespace'
+assert 'a,b,c'.split(',') == ['a', 'b', 'c'], 'split comma'
+assert 'a,b,c'.split(',', 1) == ['a', 'b,c'], 'split maxsplit'
+assert '  a  b  '.split() == ['a', 'b'], 'split multiple spaces'
+assert 'hello'.split('x') == ['hello'], 'split not found'
+
+# rsplit()
+assert 'a b c'.rsplit() == ['a', 'b', 'c'], 'rsplit whitespace'
+assert 'a,b,c'.rsplit(',') == ['a', 'b', 'c'], 'rsplit comma'
+assert 'a,b,c'.rsplit(',', 1) == ['a,b', 'c'], 'rsplit maxsplit'
+
+# splitlines()
+assert 'a\nb\nc'.splitlines() == ['a', 'b', 'c'], 'splitlines basic'
+assert 'a\nb\nc'.splitlines(True) == ['a\n', 'b\n', 'c'], 'splitlines keepends'
+assert 'a\r\nb'.splitlines() == ['a', 'b'], 'splitlines crlf'
+assert ''.splitlines() == [], 'splitlines empty'
+
+# partition()
+assert 'hello world'.partition(' ') == ('hello', ' ', 'world'), 'partition basic'
+assert 'hello'.partition('x') == ('hello', '', ''), 'partition not found'
+assert 'hello world test'.partition(' ') == ('hello', ' ', 'world test'), 'partition first'
+
+# rpartition()
+assert 'hello world'.rpartition(' ') == ('hello', ' ', 'world'), 'rpartition basic'
+assert 'hello'.rpartition('x') == ('', '', 'hello'), 'rpartition not found'
+assert 'hello world test'.rpartition(' ') == ('hello world', ' ', 'test'), 'rpartition last'
+
+# === Phase 6: Replace/modify methods ===
+
+# replace()
+assert 'hello'.replace('l', 'L') == 'heLLo', 'replace basic'
+assert 'hello'.replace('l', 'L', 1) == 'heLlo', 'replace count'
+assert 'hello'.replace('x', 'y') == 'hello', 'replace not found'
+assert 'aaa'.replace('a', 'b') == 'bbb', 'replace all'
+assert ''.replace('a', 'b') == '', 'replace empty'
+
+# center()
+assert 'hi'.center(6) == '  hi  ', 'center basic'
+assert 'hi'.center(6, '-') == '--hi--', 'center fillchar'
+assert 'hi'.center(2) == 'hi', 'center no padding'
+assert 'hi'.center(1) == 'hi', 'center smaller'
+
+# ljust()
+assert 'hi'.ljust(6) == 'hi    ', 'ljust basic'
+assert 'hi'.ljust(6, '-') == 'hi----', 'ljust fillchar'
+assert 'hi'.ljust(2) == 'hi', 'ljust no padding'
+
+# rjust()
+assert 'hi'.rjust(6) == '    hi', 'rjust basic'
+assert 'hi'.rjust(6, '-') == '----hi', 'rjust fillchar'
+assert 'hi'.rjust(2) == 'hi', 'rjust no padding'
+
+# zfill()
+assert '42'.zfill(5) == '00042', 'zfill basic'
+assert '-42'.zfill(5) == '-0042', 'zfill negative'
+assert '+42'.zfill(5) == '+0042', 'zfill positive'
+assert '42'.zfill(2) == '42', 'zfill no padding'
+assert ''.zfill(3) == '000', 'zfill empty'
+
+# === Phase 7: Additional tests for Python compatibility ===
+
+# startswith/endswith with tuple
+assert 'hello'.startswith(('he', 'lo')) == True, 'startswith tuple first match'
+assert 'hello'.startswith(('lo', 'he')) == True, 'startswith tuple second match'
+assert 'hello'.startswith(('x', 'y')) == False, 'startswith tuple no match'
+assert 'hello'.endswith(('he', 'lo')) == True, 'endswith tuple first match'
+assert 'hello'.endswith(('lo', 'he')) == True, 'endswith tuple second match'
+assert 'hello'.endswith(('x', 'y')) == False, 'endswith tuple no match'
+assert 'hello'.startswith(('ell',), 1) == True, 'startswith tuple with start'
+
+# find/rfind/index/rindex/count with None as start/end
+assert 'hello'.find('l', None) == 2, 'find with None start'
+assert 'hello'.find('l', None, None) == 2, 'find with None start and end'
+assert 'hello'.find('l', 0, None) == 2, 'find with None end'
+assert 'hello'.rfind('l', None, None) == 3, 'rfind with None start and end'
+assert 'hello'.count('l', None, None) == 2, 'count with None start and end'
+assert 'hello'.startswith('he', None) == True, 'startswith with None start'
+assert 'hello'.endswith('lo', None, None) == True, 'endswith with None start and end'
+
+# strip with None
+assert '  hello  '.strip(None) == 'hello', 'strip None same as no arg'
+assert '  hello  '.lstrip(None) == 'hello  ', 'lstrip None same as no arg'
+assert '  hello  '.rstrip(None) == '  hello', 'rstrip None same as no arg'
+
+# === Phase 8: Keyword argument tests ===
+
+# split with keyword args
+assert 'a,b,c'.split(sep=',') == ['a', 'b', 'c'], 'split sep kwarg'
+assert 'a,b,c'.split(',', maxsplit=1) == ['a', 'b,c'], 'split maxsplit kwarg'
+assert 'a,b,c'.split(sep=',', maxsplit=1) == ['a', 'b,c'], 'split both kwargs'
+
+# rsplit with keyword args
+assert 'a,b,c'.rsplit(sep=',') == ['a', 'b', 'c'], 'rsplit sep kwarg'
+assert 'a,b,c'.rsplit(',', maxsplit=1) == ['a,b', 'c'], 'rsplit maxsplit kwarg'
+assert 'a,b,c'.rsplit(sep=',', maxsplit=1) == ['a,b', 'c'], 'rsplit both kwargs'
+
+# splitlines with keyword args
+assert 'a\nb\nc'.splitlines(keepends=True) == ['a\n', 'b\n', 'c'], 'splitlines keepends kwarg'
+assert 'a\nb\nc'.splitlines(keepends=False) == ['a', 'b', 'c'], 'splitlines keepends=False'
+
+# replace with keyword args
+assert 'aaa'.replace('a', 'b', count=2) == 'bba', 'replace count kwarg'
+
+# === Phase 9: Additional methods ===
+
+# encode()
+assert 'hello'.encode() == b'hello', 'encode default'
+assert 'hello'.encode('utf-8') == b'hello', 'encode utf-8'
+assert 'hello'.encode('utf8') == b'hello', 'encode utf8 alias'
+assert 'hello'.encode('UTF-8') == b'hello', 'encode UTF-8 case insensitive'
+assert ''.encode() == b'', 'encode empty'
+assert 'hello'.encode('utf-8', 'strict') == b'hello', 'encode with errors'
+
+# isidentifier()
+assert 'hello'.isidentifier() == True, 'isidentifier basic'
+assert '_hello'.isidentifier() == True, 'isidentifier underscore'
+assert '__init__'.isidentifier() == True, 'isidentifier dunder'
+assert 'hello123'.isidentifier() == True, 'isidentifier with digits'
+assert ''.isidentifier() == False, 'isidentifier empty'
+assert '123hello'.isidentifier() == False, 'isidentifier digit start'
+assert 'hello world'.isidentifier() == False, 'isidentifier with space'
+assert 'hello-world'.isidentifier() == False, 'isidentifier with dash'
+assert 'class'.isidentifier() == True, 'isidentifier keyword'  # isidentifier doesn't check keywords
+
+# istitle()
+assert 'Hello World'.istitle() == True, 'istitle basic'
+assert 'Hello'.istitle() == True, 'istitle single word'
+assert 'HELLO'.istitle() == False, 'istitle all upper'
+assert 'hello'.istitle() == False, 'istitle all lower'
+assert ''.istitle() == False, 'istitle empty'
+assert 'Hello world'.istitle() == False, 'istitle lowercase word'
+assert '123'.istitle() == False, 'istitle numbers only'
+assert 'Hello 123 World'.istitle() == True, 'istitle with numbers'
+assert "They'Re".istitle() == True, 'istitle apostrophe'
+
+# === Phase 10: Unicode support for is* methods ===
+
+# isdecimal with Unicode decimal digits
+assert '٠١٢٣٤٥٦٧٨٩'.isdecimal() == True, 'isdecimal Arabic-Indic'
+assert '０１２３４５６７８９'.isdecimal() == True, 'isdecimal Fullwidth'
+assert '०१२३४५६७८९'.isdecimal() == True, 'isdecimal Devanagari'
+assert '²'.isdecimal() == False, 'isdecimal superscript not decimal'
+assert '½'.isdecimal() == False, 'isdecimal fraction not decimal'
+
+# isdigit with superscripts and subscripts
+assert '²³'.isdigit() == True, 'isdigit superscripts'
+assert '₀₁₂₃₄₅₆₇₈₉'.isdigit() == True, 'isdigit subscripts'
+assert '0123456789'.isdigit() == True, 'isdigit ASCII'
+assert '٠١٢٣٤٥٦٧٨٩'.isdigit() == True, 'isdigit Arabic-Indic'
+assert '½'.isdigit() == False, 'isdigit fraction not digit'
+
+# isnumeric with fractions and other numerics
+assert '½'.isnumeric() == True, 'isnumeric fraction'
+assert '²'.isnumeric() == True, 'isnumeric superscript'
+assert '٠١٢٣٤٥٦٧٨٩'.isnumeric() == True, 'isnumeric Arabic-Indic'
+assert '0123456789'.isnumeric() == True, 'isnumeric ASCII'

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

@@ -0,0 +1,162 @@
+# === String concatenation (+) ===
+assert 'hello' + ' ' + 'world' == 'hello world', 'basic concat'
+assert '' + 'test' == 'test', 'empty left concat'
+assert 'test' + '' == 'test', 'empty right concat'
+assert '' + '' == '', 'empty both concat'
+assert 'a' + 'b' + 'c' + 'd' == 'abcd', 'multiple concat'
+
+# === Augmented assignment (+=) ===
+s = 'hello'
+s += ' world'
+assert s == 'hello world', 'basic iadd'
+
+s = 'test'
+s += ''
+assert s == 'test', 'iadd empty'
+
+s = 'a'
+s += 'b'
+s += 'c'
+assert s == 'abc', 'multiple iadd'
+
+s = 'ab'
+s += s
+assert s == 'abab', 'iadd self'
+
+# === String length ===
+assert len('') == 0, 'len empty'
+assert len('a') == 1, 'len single'
+assert len('hello') == 5, 'len basic'
+assert len('hello world') == 11, 'len with space'
+assert len('caf\xe9') == 4, 'len unicode'
+
+# === String repr/str ===
+assert repr('') == "''", 'empty string repr'
+assert str('') == '', 'empty string str'
+
+assert repr('hello') == "'hello'", 'string repr'
+assert str('hello') == 'hello', 'string str'
+
+assert repr('hello "world"') == '\'hello "world"\'', 'string with quotes repr'
+assert str('hello "world"') == 'hello "world"', 'string with quotes str'
+
+# === String repetition (*) ===
+assert 'ab' * 3 == 'ababab', 'str mult int'
+assert 3 * 'ab' == 'ababab', 'int mult str'
+assert 'x' * 0 == '', 'str mult zero'
+assert 'x' * -1 == '', 'str mult negative'
+assert '' * 5 == '', 'empty str mult'
+assert 'a' * 1 == 'a', 'str mult one'
+
+# === String repetition augmented assignment (*=) ===
+s = 'ab'
+s *= 3
+assert s == 'ababab', 'str imult'
+
+s = 'x'
+s *= 0
+assert s == '', 'str imult zero'
+
+# === String join method ===
+# Basic join on literals
+assert ','.join(['a', 'b', 'c']) == 'a,b,c', 'join list with comma'
+assert ''.join(['a', 'b', 'c']) == 'abc', 'join with empty separator'
+assert '-'.join([]) == '', 'join empty list'
+assert ','.join(['only']) == 'only', 'join single element'
+
+# Join with different iterables
+assert ' '.join(('hello', 'world')) == 'hello world', 'join tuple'
+
+# Join with string iterable (iterates over characters)
+assert ','.join('abc') == 'a,b,c', 'join string iterable'
+
+# Join with variable separator
+sep = '-'
+assert sep.join(['a', 'b']) == 'a-b', 'join with variable separator'
+
+# Heap-allocated string separator
+s = str('.')
+assert s.join(['a', 'b']) == 'a.b', 'join with heap string'
+
+# Mixed string types in iterable (interned and heap)
+mixed = ['hello', str('world')]
+assert ' '.join(mixed) == 'hello world', 'join with mixed string types'
+
+# === String indexing (getitem) ===
+# Basic indexing
+assert 'hello'[0] == 'h', 'getitem index 0'
+assert 'hello'[1] == 'e', 'getitem index 1'
+assert 'hello'[4] == 'o', 'getitem last index'
+
+# Negative indexing
+assert 'hello'[-1] == 'o', 'getitem -1'
+assert 'hello'[-2] == 'l', 'getitem -2'
+assert 'hello'[-5] == 'h', 'getitem -5'
+
+# Single character strings
+assert 'a'[0] == 'a', 'getitem single char at 0'
+assert 'a'[-1] == 'a', 'getitem single char at -1'
+
+# Unicode strings
+s = 'café'
+assert s[0] == 'c', 'unicode getitem 0'
+assert s[1] == 'a', 'unicode getitem 1'
+assert s[2] == 'f', 'unicode getitem 2'
+assert s[3] == 'é', 'unicode getitem 3 (accented)'
+assert s[-1] == 'é', 'unicode getitem -1'
+
+# Multi-byte unicode (CJK characters)
+s = '日本語'
+assert s[0] == '日', 'cjk getitem 0'
+assert s[1] == '本', 'cjk getitem 1'
+assert s[2] == '語', 'cjk getitem 2'
+assert s[-1] == '語', 'cjk getitem -1'
+
+# Emoji (multi-byte UTF-8)
+s = 'a🎉b'
+assert s[0] == 'a', 'emoji string getitem 0'
+assert s[1] == '🎉', 'emoji string getitem 1 (emoji)'
+assert s[2] == 'b', 'emoji string getitem 2'
+
+# Heap-allocated strings
+s = str('hello')
+assert s[0] == 'h', 'heap string getitem'
+assert s[-1] == 'o', 'heap string negative getitem'
+
+# Variable index
+s = 'abc'
+i = 1
+assert s[i] == 'b', 'getitem with variable index'
+
+# Bool indices (True=1, False=0)
+s = 'abc'
+assert s[False] == 'a', 'str getitem with False'
+assert s[True] == 'b', 'str getitem with True'
+
+# === Sorting and comparisons ===
+assert 'a' < 'b', 'str < str'
+assert 'b' > 'a', 'str > str'
+assert 'a' <= 'a', 'str <= str equal'
+assert 'a' <= 'b', 'str <= str less'
+assert 'b' >= 'b', 'str >= str equal'
+assert 'b' >= 'a', 'str >= str greater'
+assert not ('b' < 'a'), 'str not < str'
+assert not ('a' > 'b'), 'str not > str'
+
+# Different lengths
+assert 'a' < 'aa', 'shorter prefix is less'
+assert 'ab' < 'b', 'first char decides'
+assert '' < 'a', 'empty string is less'
+assert 'abc' > 'ab', 'longer string with same prefix is greater'
+
+# Non-ASCII comparisons (by Unicode code point)
+assert 'café' < 'cafë', 'non-ascii comparison (é < ë)'
+assert 'z' < 'é', 'ascii < non-ascii (z < é)'
+assert '日' < '本', 'CJK comparison by code point'
+assert '😀' < '😁', 'emoji comparison by code point'
+
+# Sorting
+assert sorted('cba') == ['a', 'b', 'c'], 'sorted string'
+assert sorted(['b', 'c', 'a']) == ['a', 'b', 'c'], 'sorted list of strings'
+assert sorted(['café', 'cafë', 'cafa']) == ['cafa', 'café', 'cafë'], 'sorted non-ascii strings'
+assert sorted(['bb', 'a', 'ba']) == ['a', 'ba', 'bb'], 'sorted different length strings'

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

@@ -0,0 +1,9 @@
+'hello'.partition('')
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "str__partition_empty.py", line 1, in <module>
+    'hello'.partition('')
+    ~~~~~~~~~~~~~~~~~~~~~
+ValueError: empty separator
+"""

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

@@ -0,0 +1,9 @@
+'hello'.rsplit('')
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "str__rsplit_empty_sep.py", line 1, in <module>
+    'hello'.rsplit('')
+    ~~~~~~~~~~~~~~~~~~
+ValueError: empty separator
+"""

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

@@ -0,0 +1,9 @@
+'hello'.split('')
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "str__split_empty_sep.py", line 1, in <module>
+    'hello'.split('')
+    ~~~~~~~~~~~~~~~~~
+ValueError: empty separator
+"""

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

@@ -0,0 +1,7 @@
+# Tests for sys module types
+
+import sys
+
+# === Verify type() returns _io.TextIOWrapper for stdout/stderr ===
+assert str(type(sys.stdout)) == "<class '_io.TextIOWrapper'>", 'type(stdout) is _io.TextIOWrapper'
+assert str(type(sys.stderr)) == "<class '_io.TextIOWrapper'>", 'type(stderr) is _io.TextIOWrapper'

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

@@ -0,0 +1,30 @@
+def foo():
+    1 / 0
+
+
+def bar():
+    foo()
+
+
+def baz():
+    bar()
+
+
+baz()
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "traceback__division_error.py", line 13, in <module>
+    baz()
+    ~~~~~
+  File "traceback__division_error.py", line 10, in baz
+    bar()
+    ~~~~~
+  File "traceback__division_error.py", line 6, in bar
+    foo()
+    ~~~~~
+  File "traceback__division_error.py", line 2, in foo
+    1 / 0
+    ~~~~~
+ZeroDivisionError: division by zero
+"""

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

@@ -0,0 +1,17 @@
+def foo():
+    a = []
+    a[1]
+
+
+foo()
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "traceback__index_error.py", line 6, in <module>
+    foo()
+    ~~~~~
+  File "traceback__index_error.py", line 3, in foo
+    a[1]
+    ~~~~
+IndexError: list index out of range
+"""