superacli 1.1.6 → 1.1.8

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

@@ -1,19 +0,0 @@
-# === tuple.index() ===
-t = (1, 2, 3, 2)
-assert t.index(2) == 1, 'index finds first occurrence'
-assert t.index(3) == 2, 'index finds element'
-assert t.index(2, 2) == 3, 'index with start'
-assert t.index(2, 1, 4) == 1, 'index with start and end'
-
-t = ('a', 'b', 'c')
-assert t.index('b') == 1, 'index string in tuple'
-
-# === tuple.count() ===
-t = (1, 2, 2, 3, 2)
-assert t.count(2) == 3, 'count multiple occurrences'
-assert t.count(1) == 1, 'count single occurrence'
-assert t.count(4) == 0, 'count zero occurrences'
-assert ().count(1) == 0, 'count on empty tuple'
-
-t = ('a', 'b', 'a')
-assert t.count('a') == 2, 'count strings'

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

@@ -1,133 +0,0 @@
-# === Empty tuple identity (singleton optimization) ===
-# In Python, () is () is always True because empty tuples are interned
-assert () is (), 'empty tuple identity'
-assert tuple() is (), 'tuple() is empty tuple'
-assert tuple() is tuple(), 'tuple() identity'
-a = ()
-b = ()
-assert a is b, 'empty tuple vars are same object'
-# Empty tuple from operations
-assert (1,)[1:] is (), 'slice to empty is singleton'
-assert (1, 2) * 0 is (), 'mult by 0 is empty singleton'
-
-# === Tuple length ===
-assert len(()) == 0, 'len empty'
-assert len((1,)) == 1, 'len single'
-assert len((1, 2, 3)) == 3, 'len basic'
-
-# === Tuple indexing ===
-a = (1, 2, 3)
-assert a[1] == 2, 'getitem basic'
-
-a = ('a', 'b', 'c')
-assert a[0 - 2] == 'b', 'getitem negative'
-assert a[-1] == 'c', 'getitem -1'
-
-# === Nested tuples ===
-assert ((1, 2), (3, 4)) == ((1, 2), (3, 4)), 'nested tuple'
-
-# === Tuple repr/str ===
-assert repr((1, 2)) == '(1, 2)', 'tuple repr'
-assert str((1, 2)) == '(1, 2)', 'tuple str'
-
-# === Tuple concatenation (+) ===
-assert (1, 2) + (3, 4) == (1, 2, 3, 4), 'tuple add basic'
-assert () + (1, 2) == (1, 2), 'empty add tuple'
-assert (1, 2) + () == (1, 2), 'tuple add empty'
-assert () + () == (), 'empty add empty'
-assert ('a', 'b') + ('c',) == ('a', 'b', 'c'), 'tuple add strings'
-assert ((1, 2),) + ((3, 4),) == ((1, 2), (3, 4)), 'tuple add nested'
-
-# === Tuple repetition (*) ===
-assert (1, 2) * 3 == (1, 2, 1, 2, 1, 2), 'tuple mult int'
-assert 3 * (1, 2) == (1, 2, 1, 2, 1, 2), 'int mult tuple'
-assert (1,) * 0 == (), 'tuple mult zero'
-assert (1,) * -1 == (), 'tuple mult negative'
-assert () * 5 == (), 'empty tuple mult'
-assert (1, 2) * 1 == (1, 2), 'tuple mult one'
-
-# === Tuple augmented assignment edge cases ===
-t = ([1],)
-try:
-    t[0] += [2]
-    assert False, 'tuple item augmented assignment should fail'
-except TypeError as e:
-    assert e.args == ("'tuple' object does not support item assignment",), 'tuple += error matches CPython'
-    assert t == ([1, 2],), 'inner list mutation happens before tuple store fails'
-
-# === tuple() constructor ===
-assert tuple() == (), 'tuple() empty'
-assert tuple([1, 2, 3]) == (1, 2, 3), 'tuple from list'
-assert tuple((1, 2, 3)) == (1, 2, 3), 'tuple from tuple'
-assert tuple(range(3)) == (0, 1, 2), 'tuple from range'
-assert tuple('abc') == ('a', 'b', 'c'), 'tuple from string'
-assert tuple(b'abc') == (97, 98, 99), 'tuple from bytes'
-assert tuple({'a': 1, 'b': 2}) == ('a', 'b'), 'tuple from dict yields keys'
-
-# non-ASCII strings (multi-byte UTF-8)
-assert tuple('héllo') == ('h', 'é', 'l', 'l', 'o'), 'tuple from string with accented char'
-assert tuple('日本') == ('日', '本'), 'tuple from string with CJK chars'
-assert tuple('a🎉b') == ('a', '🎉', 'b'), 'tuple from string with emoji'
-
-# === Tuple unpacking (PEP 448) ===
-a = (1, 2)
-b = (3, 4)
-assert (*a,) == (1, 2), 'single tuple unpack'
-assert (*a, *b) == (1, 2, 3, 4), 'double tuple unpack'
-assert (0, *a, 5) == (0, 1, 2, 5), 'mixed tuple unpack'
-assert (*(),) == (), 'unpack empty tuple'
-assert (*[1, 2],) == (1, 2), 'unpack list into tuple'
-
-# === Tuple comparison (<, >, <=, >=) ===
-assert (1, 2) < (1, 3), 'lt second element differs'
-assert (1,) < (2,), 'lt single element'
-assert () < (1,), 'lt empty vs non-empty'
-assert (1, 2) < (1, 2, 3), 'lt shorter tuple'
-assert not (1, 2) < (1, 2), 'not lt when equal'
-assert not (1, 3) < (1, 2), 'not lt when greater'
-
-assert (1, 3) > (1, 2), 'gt second element'
-assert (2,) > (1,), 'gt single element'
-assert (1,) > (), 'gt non-empty vs empty'
-assert (1, 2, 3) > (1, 2), 'gt longer tuple'
-assert not (1, 2) > (1, 2), 'not gt when equal'
-
-assert (1, 2) <= (1, 2), 'le when equal'
-assert (1, 2) <= (1, 3), 'le when less'
-assert not (1, 3) <= (1, 2), 'not le when greater'
-
-assert (1, 2) >= (1, 2), 'ge when equal'
-assert (1, 3) >= (1, 2), 'ge when greater'
-assert not (1, 2) >= (1, 3), 'not ge when less'
-
-# === Tuple comparison with sorted() ===
-assert sorted([(2, 'b'), (1, 'a')]) == [(1, 'a'), (2, 'b')], 'sorted tuples'
-assert sorted([(1, 'b'), (1, 'a')]) == [(1, 'a'), (1, 'b')], 'sorted tuples second element'
-assert sorted([(3,), (1,), (2,)]) == [(1,), (2,), (3,)], 'sorted single-element tuples'
-
-# === Nested tuple comparison ===
-assert ((1, 2), 3) < ((1, 3), 2), 'nested tuple comparison'
-assert (1, (2, 3)) < (1, (2, 4)), 'nested tuple inner comparison'
-
-# === Equal-but-unorderable elements (None, lists, dicts) ===
-# CPython checks __eq__ first; equal elements skip ordering comparison
-assert not (1, None) < (1, None), 'equal None elements not lt'
-assert (1, None) <= (1, None), 'equal None elements le'
-assert (1, None) >= (1, None), 'equal None elements ge'
-assert not (1, None) > (1, None), 'equal None elements not gt'
-assert (1, None) < (2, None), 'first element resolves before None'
-assert (1, [1, 2]) <= (1, [1, 2]), 'equal list elements le'
-
-# === Mixed types in tuple comparison ===
-assert (1,) < (2.0,), 'int vs float in tuple'
-assert (1.0,) < (2,), 'float vs int in tuple'
-assert (True,) < (2,), 'bool vs int in tuple'
-assert (False,) < (True,), 'False vs True in tuple'
-assert (1, 'a') < (1, 'b'), 'string comparison in tuple'
-assert ('a', 1) < ('b', 1), 'string first element in tuple'
-
-# === Empty and equal tuples ===
-assert not () < (), 'empty tuples not lt'
-assert () <= (), 'empty tuples le'
-assert () >= (), 'empty tuples ge'
-assert not () > (), 'empty tuples not gt'

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

@@ -1,2 +0,0 @@
-(*42,)
-# Raise=TypeError('Value after * must be an iterable, not int')

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

@@ -1,9 +0,0 @@
-x = len
-x.nonexistent
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "type__builtin_attr_error.py", line 2, in <module>
-    x.nonexistent
-AttributeError: 'builtin_function_or_method' object has no attribute 'nonexistent'
-"""

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

@@ -1,2 +0,0 @@
-bytes(-1)
-# Raise=ValueError('negative count')

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

@@ -1,9 +0,0 @@
-print(cell)
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "type__cell_not_builtin.py", line 1, in <module>
-    print(cell)
-          ~~~~
-NameError: name 'cell' is not defined
-"""

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

@@ -1,11 +0,0 @@
-# Regression test for: "fmt() called on disabled variant" panic
-# Type::Exception must be displayable in error messages.
-e = ValueError('test')
-e.nonexistent
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "type__exception_attr_error.py", line 4, in <module>
-    e.nonexistent
-AttributeError: 'ValueError' object has no attribute 'nonexistent'
-"""

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

@@ -1,2 +0,0 @@
-float([1, 2])
-# Raise=TypeError("float() argument must be a string or a real number, not 'list'")

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

@@ -1,9 +0,0 @@
-float("it's \"nice\"")
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "type__float_repr_both_quotes.py", line 1, in <module>
-    float("it's \"nice\"")
-    ~~~~~~~~~~~~~~~~~~~~~~
-ValueError: could not convert string to float: 'it\'s "nice"'
-"""

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

@@ -1,9 +0,0 @@
-float("a\nb")
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "type__float_repr_newline.py", line 1, in <module>
-    float("a\nb")
-    ~~~~~~~~~~~~~
-ValueError: could not convert string to float: 'a\nb'
-"""

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

@@ -1,9 +0,0 @@
-float("it's")
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "type__float_repr_single_quote.py", line 1, in <module>
-    float("it's")
-    ~~~~~~~~~~~~~
-ValueError: could not convert string to float: "it's"
-"""

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

@@ -1,2 +0,0 @@
-int([1, 2])
-# Raise=TypeError("int() argument must be a string, a bytes-like object or a real number, not 'list'")

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

@@ -1,2 +0,0 @@
-list(123)
-# Raise=TypeError("'int' object is not iterable")

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

@@ -1,9 +0,0 @@
-print(TextIOWrapper)
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "type__non_builtin_name_error.py", line 1, in <module>
-    print(TextIOWrapper)
-          ~~~~~~~~~~~~~
-NameError: name 'TextIOWrapper' is not defined
-"""

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

@@ -1,200 +0,0 @@
-# === type() function ===
-assert type(1) == int, 'type(int) returns int'
-assert type(1.5) == float, 'type(float) returns float'
-assert type(True) == bool, 'type(bool) returns bool'
-assert type('hello') == str, 'type(str) returns str'
-assert type([1, 2]) == list, 'type(list) returns list'
-assert type((1, 2)) == tuple, 'type(tuple) returns tuple'
-assert type({1: 2}) == dict, 'type(dict) returns dict'
-assert type(b'hi') == bytes, 'type(bytes) returns bytes'
-assert type(None) == type(None), 'type(None) is consistent'
-
-# === type() inequality ===
-assert type(1) != str, 'int type != str'
-assert type([]) != tuple, 'list type != tuple'
-assert type({}) != list, 'dict type != list'
-assert type(1) != float, 'int type != float'
-
-# === type repr ===
-assert repr(int) == "<class 'int'>", 'int type repr'
-assert repr(float) == "<class 'float'>", 'float type repr'
-assert repr(bool) == "<class 'bool'>", 'bool type repr'
-assert repr(str) == "<class 'str'>", 'str type repr'
-assert repr(list) == "<class 'list'>", 'list type repr'
-assert repr(tuple) == "<class 'tuple'>", 'tuple type repr'
-assert repr(dict) == "<class 'dict'>", 'dict type repr'
-assert repr(bytes) == "<class 'bytes'>", 'bytes type repr'
-
-# === type identity ===
-assert int is int, 'int is int'
-assert str is str, 'str is str'
-assert list is list, 'list is list'
-assert type(1) is int, 'type(1) is int'
-assert type('') is str, 'type str is str'
-assert type([]) is list, 'type([]) is list'
-
-# === list() constructor ===
-assert list() == [], 'list() empty'
-assert list([1, 2, 3]) == [1, 2, 3], 'list(list) copy'
-assert list((1, 2, 3)) == [1, 2, 3], 'list(tuple) convert'
-assert list(range(3)) == [0, 1, 2], 'list(range) convert'
-assert list('abc') == ['a', 'b', 'c'], 'list(str) split chars'
-assert list('') == [], 'list empty str'
-
-# list copy is independent
-orig = [1, 2, 3]
-copy = list(orig)
-copy.append(4)
-assert orig == [1, 2, 3], 'list copy is independent'
-assert copy == [1, 2, 3, 4], 'list copy modified'
-
-# === tuple() constructor ===
-assert tuple() == (), 'tuple() empty'
-assert tuple([1, 2, 3]) == (1, 2, 3), 'tuple(list) convert'
-assert tuple((1, 2)) == (1, 2), 'tuple(tuple) copy'
-assert tuple(range(3)) == (0, 1, 2), 'tuple(range) convert'
-assert tuple('ab') == ('a', 'b'), 'tuple(str) split chars'
-assert tuple('') == (), 'tuple empty str'
-
-# === dict() constructor ===
-assert dict() == {}, 'dict() empty'
-assert dict({1: 2}) == {1: 2}, 'dict(dict) copy'
-assert dict({'a': 1, 'b': 2}) == {'a': 1, 'b': 2}, 'dict(dict) multiple keys'
-
-# dict copy is independent
-orig_dict = {1: 2}
-copy_dict = dict(orig_dict)
-copy_dict[3] = 4
-assert orig_dict == {1: 2}, 'dict copy is independent'
-assert copy_dict == {1: 2, 3: 4}, 'dict copy modified'
-assert dict([('a', 1), ('b', 2)]) == {'a': 1, 'b': 2}, 'dict(list of tuples)'
-assert dict((('a', 1), ('b', 2))) == {'a': 1, 'b': 2}, 'dict(tuple of tuples)'
-
-headers = ['a', 'b']
-row_data = [1, 2]
-assert dict(zip(headers, row_data)) == {'a': 1, 'b': 2}, 'dict(zip(list, list))'
-assert dict(zip(['a', 'b'], [1])) == {'a': 1}, 'dict(zip()) truncates to shortest iterable'
-
-assert dict(a=1, b=2) == {'a': 1, 'b': 2}, 'dict keyword arguments'
-assert dict([('a', 1)], b=2) == {'a': 1, 'b': 2}, 'dict positional iterable plus kwargs'
-assert dict([('a', 1)], a=2) == {'a': 2}, 'dict kwargs overwrite positional iterable values'
-
-# === str() constructor ===
-assert str() == '', 'str() empty'
-assert str(123) == '123', 'str(int)'
-assert str(-42) == '-42', 'str(negative int)'
-assert str(0) == '0', 'str(zero)'
-assert str(1.5) == '1.5', 'str(float)'
-assert str(True) == 'True', 'str(bool True)'
-assert str(False) == 'False', 'str(bool False)'
-assert str(None) == 'None', 'str(None)'
-assert str([1, 2]) == '[1, 2]', 'str(list)'
-assert str((1, 2)) == '(1, 2)', 'str(tuple)'
-assert str({1: 2}) == '{1: 2}', 'str(dict)'
-assert str('hello') == 'hello', 'str(str)'
-assert str(b'hi') == "b'hi'", 'str(bytes)'
-
-# === bytes() constructor ===
-assert bytes() == b'', 'bytes() empty'
-assert bytes(3) == b'\x00\x00\x00', 'bytes(int) zero-filled'
-assert bytes(0) == b'', 'bytes(0) empty'
-assert bytes(b'hi') == b'hi', 'bytes(bytes) copy'
-
-# === int() constructor ===
-assert int() == 0, 'int() default'
-assert int(42) == 42, 'int(int)'
-assert int(-5) == -5, 'int(negative int)'
-assert int(3.7) == 3, 'int(float) truncates down'
-assert int(-3.7) == -3, 'int(negative float) truncates toward zero'
-assert int(3.0) == 3, 'int(whole float)'
-assert int(True) == 1, 'int(True)'
-assert int(False) == 0, 'int(False)'
-
-# int() with extreme float values (should clamp to i64 range in Monty)
-# Note: Python uses arbitrary precision; Monty clamps to i64
-assert isinstance(int(1e18), int), 'int(large float) returns int'
-assert isinstance(int(-1e18), int), 'int(large negative float) returns int'
-assert int(0.0) == 0, 'int(0.0) is zero'
-assert int(-0.0) == 0, 'int(-0.0) is zero'
-assert int(0.9) == 0, 'int(0.9) truncates to 0'
-assert int(-0.9) == 0, 'int(-0.9) truncates to 0'
-
-# === float() constructor ===
-assert float() == 0.0, 'float() default'
-assert float(42) == 42.0, 'float(int)'
-assert float(-5) == -5.0, 'float(negative int)'
-assert float(3.14) == 3.14, 'float(float)'
-assert float(True) == 1.0, 'float(True)'
-assert float(False) == 0.0, 'float(False)'
-
-# === bool() constructor ===
-assert bool() == False, 'bool() default'
-assert bool(0) == False, 'bool(0)'
-assert bool(1) == True, 'bool(1)'
-assert bool(-1) == True, 'bool(-1)'
-assert bool(0.0) == False, 'bool(0.0)'
-assert bool(1.5) == True, 'bool(1.5)'
-assert bool('') == False, 'bool empty str'
-assert bool('x') == True, 'bool non-empty str'
-assert bool([]) == False, 'bool empty list'
-assert bool([1]) == True, 'bool non-empty list'
-assert bool(()) == False, 'bool empty tuple'
-assert bool((1,)) == True, 'bool non-empty tuple'
-assert bool({}) == False, 'bool empty dict'
-assert bool({1: 2}) == True, 'bool non-empty dict'
-assert bool(None) == False, 'bool(None)'
-
-# === isinstance() ===
-assert isinstance(1, int), 'isinstance int'
-assert isinstance(1.5, float), 'isinstance float'
-assert isinstance(True, bool), 'isinstance bool'
-assert isinstance('hello', str), 'isinstance str'
-assert isinstance([1, 2], list), 'isinstance list'
-assert isinstance((1, 2), tuple), 'isinstance tuple'
-assert isinstance({1: 2}, dict), 'isinstance dict'
-assert isinstance(b'hi', bytes), 'isinstance bytes'
-
-# isinstance negative cases
-assert not isinstance(1, str), 'isinstance int not str'
-assert not isinstance('x', int), 'isinstance str not int'
-assert not isinstance([], dict), 'isinstance list not dict'
-
-# isinstance with tuple of types
-assert isinstance(1, (int, str)), 'isinstance tuple match first'
-assert isinstance('x', (int, str)), 'isinstance tuple match second'
-assert not isinstance([], (int, str)), 'isinstance tuple no match'
-assert isinstance(1, (str, float, int)), 'isinstance tuple match third'
-
-# bool is subtype of int
-assert isinstance(True, int), 'bool is instance of int'
-assert isinstance(False, int), 'False is instance of int'
-assert isinstance(True, (int, str)), 'bool matches int in tuple'
-
-# isinstance with exception types
-err = ValueError('test')
-assert isinstance(err, ValueError), 'isinstance exception'
-assert isinstance(err, Exception), 'isinstance exception base type'
-assert not isinstance(err, TypeError), 'isinstance exception wrong type'
-assert isinstance(err, (ValueError, TypeError)), 'isinstance exception tuple'
-
-# isinstance with nested tuples
-assert isinstance('a', (int, (str, bytes))), 'isinstance nested tuple match'
-assert isinstance(1, ((str, float), int)), 'isinstance deeply nested'
-assert not isinstance([], (int, (str, bytes))), 'isinstance nested tuple no match'
-
-# NoneType capitalization
-assert repr(type(None)) == "<class 'NoneType'>", 'NoneType capitalized'
-
-# === type().__name__ ===
-assert type(42).__name__ == 'int', 'int type name'
-assert type('hello').__name__ == 'str', 'str type name'
-assert type(True).__name__ == 'bool', 'bool type name'
-assert type(None).__name__ == 'NoneType', 'NoneType name'
-assert type([1, 2]).__name__ == 'list', 'list type name'
-assert type({'a': 1}).__name__ == 'dict', 'dict type name'
-
-# type().__name__ for exceptions
-try:
-    raise ValueError('test')
-except ValueError as e:
-    assert type(e).__name__ == 'ValueError', 'exception type name'

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

@@ -1,3 +0,0 @@
-# Builtin exception type 'ValueError' can be shadowed by assignment
-ValueError = 'not an exception'
-assert ValueError == 'not an exception', 'ValueError shadowed'

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

@@ -1,9 +0,0 @@
-# Builtin type name 'int' can be shadowed by assignment
-int = 42
-assert int == 42, 'int shadowed by assignment'
-
-# for loop variable shadows builtin
-result = []
-for int in range(3):
-    result.append(int)
-assert result == [0, 1, 2], 'int works as for loop variable'

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

@@ -1,3 +0,0 @@
-# Builtin function 'len' can be shadowed by assignment
-len = 'shadowed'
-assert len == 'shadowed', 'len shadowed by assignment'

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

@@ -1,2 +0,0 @@
-tuple(123)
-# Raise=TypeError("'int' object is not iterable")

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

@@ -1,2 +0,0 @@
-2 + [1]
-# Raise=TypeError("unsupported operand type(s) for +: 'int' and 'list'")

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

@@ -1,2 +0,0 @@
-5 / 'x'
-# Raise=TypeError("unsupported operand type(s) for /: 'int' and 'str'")

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

@@ -1,2 +0,0 @@
-5 // 'x'
-# Raise=TypeError("unsupported operand type(s) for //: 'int' and 'str'")

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

@@ -1,3 +0,0 @@
-x = 5
-x += 'a'
-# Raise=TypeError("unsupported operand type(s) for +=: 'int' and 'str'")

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

@@ -1,2 +0,0 @@
-5 % 'x'
-# Raise=TypeError("unsupported operand type(s) for %: 'int' and 'str'")

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

@@ -1,2 +0,0 @@
-5 ** 'x'
-# Raise=TypeError("unsupported operand type(s) for ** or pow(): 'int' and 'str'")

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

@@ -1,2 +0,0 @@
-5 - 'x'
-# Raise=TypeError("unsupported operand type(s) for -: 'int' and 'str'")

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

@@ -1,2 +0,0 @@
-[1, 2] + 3
-# Raise=TypeError('can only concatenate list (not "int") to list')

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

@@ -1,2 +0,0 @@
-[1] + 'x'
-# Raise=TypeError('can only concatenate list (not "str") to list')

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

@@ -1,6 +0,0 @@
-# xfail=monty
-# Monty's list += only supports other lists, not arbitrary iterables.
-# CPython's list += calls extend() which requires an iterable.
-x = [1]
-x += 2
-# Raise=TypeError("'int' object is not iterable")

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

@@ -1,2 +0,0 @@
-'hello' + 1
-# Raise=TypeError('can only concatenate str (not "int") to str')

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

@@ -1,3 +0,0 @@
-x = 'hello'
-x += 1
-# Raise=TypeError('can only concatenate str (not "int") to str')

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

@@ -1,3 +0,0 @@
-# bitwise NOT on string should raise TypeError
-~'hello'
-# Raise=TypeError("bad operand type for unary ~: 'str'")

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

@@ -1,4 +0,0 @@
-# unary minus on heap-allocated string should raise TypeError
-# str() creates a heap-allocated string, triggering ref count check
--str(42)
-# Raise=TypeError("bad operand type for unary -: 'str'")

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

@@ -1,3 +0,0 @@
-# unary minus on string should raise TypeError
--'hello'
-# Raise=TypeError("bad operand type for unary -: 'str'")

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

@@ -1,4 +0,0 @@
-# unary plus on heap-allocated string should raise TypeError
-# str() creates a heap-allocated string, triggering ref count check
-+str(42)
-# Raise=TypeError("bad operand type for unary +: 'str'")

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

@@ -1,24 +0,0 @@
-# Tests for typing module type() behavior
-#
-# CPython's typing module uses various internal types for different constructs.
-# Monty simplifies this by using typing._SpecialForm for all typing markers.
-# Where CPython also uses _SpecialForm, we use == for exact match.
-# Where CPython uses different internal types, we accept both representations.
-
-import typing
-
-# === Types that match between CPython and Monty ===
-assert repr(type(typing.Optional)) == "<class 'typing._SpecialForm'>", 'type(Optional)'
-assert repr(type(typing.ClassVar)) == "<class 'typing._SpecialForm'>", 'type(ClassVar)'
-assert repr(type(typing.Final)) == "<class 'typing._SpecialForm'>", 'type(Final)'
-assert repr(type(typing.Union)) == "<class 'type'>", 'type(Union)'
-
-# === Types that differ between CPython and Monty ===
-# CPython uses specialized internal types; Monty uses _SpecialForm for all
-assert repr(type(typing.Any)) in ("<class 'typing._SpecialForm'>", "<class 'typing._AnyMeta'>"), 'type(Any)'
-assert repr(type(typing.Callable)) in ("<class 'typing._SpecialForm'>", "<class 'typing._CallableType'>"), (
-    'type(Callable)'
-)
-
-# === Verify TYPE_CHECKING is False ===
-assert typing.TYPE_CHECKING is False, 'TYPE_CHECKING should be False at runtime'

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

@@ -1,48 +0,0 @@
-# Test nested tuple unpacking
-
-# === Basic nested unpacking ===
-data = ((1, 2), 'x')
-(a, b), c = data
-assert a == 1, 'nested unpack first inner'
-assert b == 2, 'nested unpack second inner'
-assert c == 'x', 'nested unpack outer'
-
-# === Deeply nested ===
-((a, b), (c, d)) = ((1, 2), (3, 4))
-assert a == 1, 'deep nested first'
-assert b == 2, 'deep nested second'
-assert c == 3, 'deep nested third'
-assert d == 4, 'deep nested fourth'
-
-# === Mixed depths ===
-(a, (b, c)) = (1, (2, 3))
-assert a == 1, 'mixed depth outer'
-assert b == 2, 'mixed depth inner first'
-assert c == 3, 'mixed depth inner second'
-
-# === Three levels deep ===
-(a, (b, (c, d))) = (1, (2, (3, 4)))
-assert a == 1, 'three level outer'
-assert b == 2, 'three level mid'
-assert c == 3, 'three level inner first'
-assert d == 4, 'three level inner second'
-
-# === In for loops ===
-items = [((1, 2), 'a'), ((3, 4), 'b')]
-sums = []
-letters = []
-for (a, b), c in items:
-    sums.append(a + b)
-    letters.append(c)
-assert sums == [3, 7], 'for loop nested unpack sums'
-assert letters == ['a', 'b'], 'for loop nested unpack letters'
-
-# === In comprehensions ===
-items = [((1, 2), 'a'), ((3, 4), 'b')]
-result = [a + b for (a, b), c in items]
-assert result == [3, 7], 'comprehension nested unpack'
-
-# === Deep nested in comprehension ===
-items = [((1, 2), (3, 4)), ((5, 6), (7, 8))]
-result = [a + b + c + d for (a, b), (c, d) in items]
-assert result == [10, 26], 'comprehension deep nested unpack'

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

@@ -1,9 +0,0 @@
-a, b = 42
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "unpack__non_sequence.py", line 1, in <module>
-    a, b = 42
-    ~~~~
-TypeError: cannot unpack non-iterable int object
-"""