superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,148 @@
+# === min() ===
+# Basic min operations
+assert min([1, 2, 3]) == 1, 'min of list'
+assert min([3, 1, 2]) == 1, 'min of unsorted list'
+assert min([5]) == 5, 'min of single element'
+assert min(1, 2, 3) == 1, 'min of multiple args'
+assert min(3, 1, 2) == 1, 'min of unsorted args'
+assert min(-5, -10, -1) == -10, 'min of negatives'
+
+# min with strings
+assert min(['b', 'a', 'c']) == 'a', 'min of string list'
+assert min('b', 'a', 'c') == 'a', 'min of string args'
+
+# min with floats
+assert min([1.5, 0.5, 2.5]) == 0.5, 'min of floats'
+assert min(1.5, 0.5) == 0.5, 'min float args'
+
+# === max() ===
+# Basic max operations
+assert max([1, 2, 3]) == 3, 'max of list'
+assert max([3, 1, 2]) == 3, 'max of unsorted list'
+assert max([5]) == 5, 'max of single element'
+assert max(1, 2, 3) == 3, 'max of multiple args'
+assert max(3, 1, 2) == 3, 'max of unsorted args'
+assert max(-5, -10, -1) == -1, 'max of negatives'
+
+# max with strings
+assert max(['b', 'a', 'c']) == 'c', 'max of string list'
+assert max('b', 'a', 'c') == 'c', 'max of string args'
+
+# max with floats
+assert max([1.5, 0.5, 2.5]) == 2.5, 'max of floats'
+assert max(1.5, 2.5) == 2.5, 'max float args'
+
+# === sorted() ===
+# Basic sorted operations
+assert sorted([3, 1, 2]) == [1, 2, 3], 'sorted int list'
+assert sorted([1, 2, 3]) == [1, 2, 3], 'sorted already sorted'
+assert sorted([3, 2, 1]) == [1, 2, 3], 'sorted reverse order'
+assert sorted([]) == [], 'sorted empty list'
+assert sorted([5]) == [5], 'sorted single element'
+
+# sorted with strings
+assert sorted(['c', 'a', 'b']) == ['a', 'b', 'c'], 'sorted strings'
+
+# sorted with heap-allocated strings (from split)
+assert sorted('banana,apple,cherry'.split(',')) == ['apple', 'banana', 'cherry'], 'sorted split strings'
+
+# sorted with multi-char string literals (heap-allocated)
+assert sorted(['banana', 'apple', 'cherry']) == ['apple', 'banana', 'cherry'], 'sorted multi-char strings'
+
+# min/max with heap-allocated strings
+assert min('banana,apple,cherry'.split(',')) == 'apple', 'min of split strings'
+assert max('banana,apple,cherry'.split(',')) == 'cherry', 'max of split strings'
+
+# sorted with negative numbers
+assert sorted([-3, 1, -2, 2]) == [-3, -2, 1, 2], 'sorted with negatives'
+
+# sorted with tuple
+assert sorted((3, 1, 2)) == [1, 2, 3], 'sorted tuple returns list'
+
+# sorted preserves duplicates
+assert sorted([3, 1, 2, 1, 3]) == [1, 1, 2, 3, 3], 'sorted with duplicates'
+
+# sorted with range
+assert sorted(range(5, 0, -1)) == [1, 2, 3, 4, 5], 'sorted range'
+
+# === sorted() with reverse ===
+assert sorted([3, 1, 2], reverse=True) == [3, 2, 1], 'sorted reverse=True'
+assert sorted([3, 1, 2], reverse=False) == [1, 2, 3], 'sorted reverse=False'
+assert sorted(['c', 'a', 'b'], reverse=True) == ['c', 'b', 'a'], 'sorted strings reverse'
+assert sorted([], reverse=True) == [], 'sorted empty reverse'
+assert sorted([5], reverse=True) == [5], 'sorted single reverse'
+assert sorted([3, 1, 2], reverse=0) == [1, 2, 3], 'sorted reverse=0 (falsy)'
+assert sorted([3, 1, 2], reverse=1) == [3, 2, 1], 'sorted reverse=1 (truthy)'
+
+# === sorted() with key ===
+assert sorted([3, -1, 2, -4], key=abs) == [-1, 2, 3, -4], 'sorted key=abs'
+assert sorted(['banana', 'apple', 'cherry'], key=len) == ['apple', 'banana', 'cherry'], 'sorted key=len'
+assert sorted([3, 1, 2], key=None) == [1, 2, 3], 'sorted key=None same as no key'
+
+
+def negate(x):
+    return -x
+
+
+assert sorted([1, -2, 3], key=negate) == [3, 1, -2], 'sorted key=user-defined function'
+
+# === sorted() with key and reverse ===
+assert sorted([3, -1, 2, -4], key=abs, reverse=True) == [-4, 3, 2, -1], 'sorted key=abs reverse=True'
+assert sorted(['banana', 'apple', 'cherry'], key=len, reverse=True) == ['banana', 'cherry', 'apple'], (
+    'sorted key=len reverse=True'
+)
+assert sorted([3, 1, 2], key=None, reverse=True) == [3, 2, 1], 'sorted key=None reverse=True'
+
+# === reversed() ===
+# Basic reversed operations
+assert list(reversed([1, 2, 3])) == [3, 2, 1], 'reversed list'
+assert list(reversed([1])) == [1], 'reversed single element'
+assert list(reversed([])) == [], 'reversed empty list'
+
+# reversed tuple
+assert list(reversed((1, 2, 3))) == [3, 2, 1], 'reversed tuple'
+
+# reversed string
+assert list(reversed('abc')) == ['c', 'b', 'a'], 'reversed string'
+
+# reversed range
+assert list(reversed(range(1, 4))) == [3, 2, 1], 'reversed range'
+
+# === enumerate() ===
+# Basic enumerate operations
+assert list(enumerate(['a', 'b', 'c'])) == [(0, 'a'), (1, 'b'), (2, 'c')], 'enumerate list'
+assert list(enumerate([])) == [], 'enumerate empty list'
+assert list(enumerate(['x'])) == [(0, 'x')], 'enumerate single element'
+
+# enumerate with start
+assert list(enumerate(['a', 'b'], 1)) == [(1, 'a'), (2, 'b')], 'enumerate with start'
+assert list(enumerate(['a', 'b'], 10)) == [(10, 'a'), (11, 'b')], 'enumerate with start 10'
+
+# enumerate string
+assert list(enumerate('ab')) == [(0, 'a'), (1, 'b')], 'enumerate string'
+
+# enumerate range
+assert list(enumerate(range(3))) == [(0, 0), (1, 1), (2, 2)], 'enumerate range'
+
+# === zip() ===
+# Basic zip operations
+assert list(zip([1, 2], ['a', 'b'])) == [(1, 'a'), (2, 'b')], 'zip two lists'
+assert list(zip([1], ['a'])) == [(1, 'a')], 'zip single elements'
+assert list(zip([], [])) == [], 'zip empty lists'
+
+# zip truncates to shortest
+assert list(zip([1, 2, 3], ['a', 'b'])) == [(1, 'a'), (2, 'b')], 'zip truncates to shortest'
+assert list(zip([1], ['a', 'b', 'c'])) == [(1, 'a')], 'zip truncates first shorter'
+
+# zip three iterables
+assert list(zip([1, 2], ['a', 'b'], [True, False])) == [(1, 'a', True), (2, 'b', False)], 'zip three lists'
+
+# zip with different types
+assert list(zip(range(3), 'abc')) == [(0, 'a'), (1, 'b'), (2, 'c')], 'zip range and string'
+
+# zip single iterable
+assert list(zip([1, 2, 3])) == [(1,), (2,), (3,)], 'zip single iterable'
+
+# zip with empty
+assert list(zip([1, 2], [])) == [], 'zip with empty second'
+assert list(zip([], [1, 2])) == [], 'zip with empty first'

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

@@ -0,0 +1,10 @@
+it = iter([])
+next(it)
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "builtin__next_stop_iteration.py", line 2, in <module>
+    next(it)
+    ~~~~~~~~
+StopIteration
+"""

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

@@ -0,0 +1,9 @@
+print('xxx', **{"foo'": 123})
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "builtin__print_invalid_kwarg.py", line 1, in <module>
+    print('xxx', **{"foo'": 123})
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+TypeError: print() got an unexpected keyword argument 'foo''
+"""

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

@@ -0,0 +1,12 @@
+# Tests dynamic keyword arguments for print()
+
+# === Dynamic sep via **kwargs ===
+dynamic_sep = 's' + 'e' + 'p'
+result = print('left', 'right', **{dynamic_sep: '-'})
+assert result is None, 'print returns None with dynamic sep'
+
+
+# === Dynamic end via **kwargs ===
+dynamic_end = 'e' + 'n' + 'd'
+result2 = print('line', **{dynamic_end: ''})
+assert result2 is None, 'print returns None with dynamic end'

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

@@ -0,0 +1,3 @@
+# === repr of built-in functions ===
+assert repr(len) == '<built-in function len>', 'repr(len)'
+assert repr(print) == '<built-in function print>', 'repr(print)'

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

@@ -0,0 +1,73 @@
+# === ord() ===
+# Basic ord operations
+assert ord('a') == 97, 'ord lowercase a'
+assert ord('A') == 65, 'ord uppercase A'
+assert ord('0') == 48, 'ord digit 0'
+assert ord(' ') == 32, 'ord space'
+assert ord('\n') == 10, 'ord newline'
+assert ord('\t') == 9, 'ord tab'
+
+# Unicode characters
+assert ord('\u00e9') == 233, 'ord e-acute'
+assert ord('\u4e2d') == 20013, 'ord Chinese character'
+assert ord('\U0001f600') == 128512, 'ord emoji grinning face'
+
+# === chr() ===
+# Basic chr operations
+assert chr(97) == 'a', 'chr 97 = a'
+assert chr(65) == 'A', 'chr 65 = A'
+assert chr(48) == '0', 'chr 48 = 0'
+assert chr(32) == ' ', 'chr 32 = space'
+assert chr(10) == '\n', 'chr 10 = newline'
+
+# Unicode characters
+assert chr(233) == '\u00e9', 'chr 233 = e-acute'
+assert chr(20013) == '\u4e2d', 'chr 20013 = Chinese char'
+assert chr(128512) == '\U0001f600', 'chr emoji'
+
+# Edge cases
+assert chr(0) == '\x00', 'chr 0 = null'
+assert chr(0x10FFFF) != '', 'chr max unicode'
+
+# Round-trip test
+assert chr(ord('x')) == 'x', 'ord/chr roundtrip'
+assert ord(chr(1000)) == 1000, 'chr/ord roundtrip'
+
+# === bin() ===
+# Basic bin operations
+assert bin(0) == '0b0', 'bin 0'
+assert bin(1) == '0b1', 'bin 1'
+assert bin(2) == '0b10', 'bin 2'
+assert bin(5) == '0b101', 'bin 5'
+assert bin(255) == '0b11111111', 'bin 255'
+assert bin(-5) == '-0b101', 'bin negative'
+assert bin(True) == '0b1', 'bin True'
+assert bin(False) == '0b0', 'bin False'
+MIN_I64 = -9223372036854775807 - 1  # Smallest i64
+MIN_I64_BIN = '1' + '0' * 63
+MIN_I64_HEX = '8' + '0' * 15
+MIN_I64_OCT = '1' + '0' * 21
+assert bin(MIN_I64) == '-0b' + MIN_I64_BIN, 'bin handles i64::MIN without overflow'
+
+# === hex() ===
+# Basic hex operations
+assert hex(0) == '0x0', 'hex 0'
+assert hex(15) == '0xf', 'hex 15'
+assert hex(16) == '0x10', 'hex 16'
+assert hex(255) == '0xff', 'hex 255'
+assert hex(256) == '0x100', 'hex 256'
+assert hex(-42) == '-0x2a', 'hex negative'
+assert hex(True) == '0x1', 'hex True'
+assert hex(False) == '0x0', 'hex False'
+assert hex(MIN_I64) == '-0x' + MIN_I64_HEX, 'hex handles i64::MIN without overflow'
+
+# === oct() ===
+# Basic oct operations
+assert oct(0) == '0o0', 'oct 0'
+assert oct(7) == '0o7', 'oct 7'
+assert oct(8) == '0o10', 'oct 8'
+assert oct(64) == '0o100', 'oct 64'
+assert oct(-56) == '-0o70', 'oct negative'
+assert oct(True) == '0o1', 'oct True'
+assert oct(False) == '0o0', 'oct False'
+assert oct(MIN_I64) == '-0o' + MIN_I64_OCT, 'oct handles i64::MIN without overflow'

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

@@ -0,0 +1,18 @@
+# Test that bytes.decode raises UnicodeDecodeError for invalid UTF-8
+# UnicodeDecodeError is a subclass of ValueError, so it should be caught by both
+
+# Test it raises UnicodeDecodeError
+raised_decode_error = False
+try:
+    b'\xff'.decode()
+except UnicodeDecodeError:
+    raised_decode_error = True
+assert raised_decode_error, 'should raise UnicodeDecodeError for invalid UTF-8'
+
+# Test it can be caught by ValueError (since UnicodeDecodeError is a subclass)
+caught_by_value_error = False
+try:
+    b'\x80\x81'.decode()
+except ValueError:
+    caught_by_value_error = True
+assert caught_by_value_error, 'UnicodeDecodeError should be caught by except ValueError'

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

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

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

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

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

@@ -0,0 +1,10 @@
+# Test that bytes.index with start > end doesn't panic but raises ValueError
+b'hello'.index(b'e', 5, 2)
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "bytes__index_start_gt_end.py", line 2, in <module>
+    b'hello'.index(b'e', 5, 2)
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+ValueError: subsection not found
+"""