superacli 1.1.6 → 1.1.8

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

@@ -1,9 +0,0 @@
-# Test that heap values are properly cleaned up when missing required arg error occurs
-def f(a, b, c):
-    return a
-
-
-# The list [1, 2, 3] should be cleaned up when the error occurs
-# because 'c' is missing
-f([1, 2, 3], [4, 5])
-# Raise=TypeError("f() missing 1 required positional argument: 'c'")

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

@@ -1,7 +0,0 @@
-# Test: missing required keyword-only argument
-def f(a, *, b):
-    return a + b
-
-
-f(1)
-# Raise=TypeError("f() missing 1 required keyword-only argument: 'b'")

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

@@ -1,7 +0,0 @@
-# Test: missing positional-only when keyword is provided for other param
-def f(a, /, b):
-    return a + b
-
-
-f(b=2)
-# Raise=TypeError("f() missing 1 required positional argument: 'a'")

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

@@ -1,7 +0,0 @@
-# Test: missing required argument with positional-only params
-def f(a, b, /, c):
-    return a + b + c
-
-
-f(1, 2)
-# Raise=TypeError("f() missing 1 required positional argument: 'c'")

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

@@ -1,7 +0,0 @@
-# Test: positional-only parameter passed as keyword argument
-def f(a, b, /, c):
-    return a + b + c
-
-
-f(1, b=2, c=3)
-# Raise=TypeError("f() got some positional-only arguments passed as keyword arguments: 'b'")

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

@@ -1,7 +0,0 @@
-# Test: first positional-only parameter passed as keyword argument
-def f(a, /, b):
-    return a + b
-
-
-f(a=1, b=2)
-# Raise=TypeError("f() got some positional-only arguments passed as keyword arguments: 'a'")

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

@@ -1,7 +0,0 @@
-# Test: too many positional arguments with positional-only params
-def f(a, b, /):
-    return a + b
-
-
-f(1, 2, 3)
-# Raise=TypeError('f() takes 2 positional arguments but 3 were given')

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

@@ -1,7 +0,0 @@
-# Test: too many positional arguments with keyword-only params
-def f(a, *, b):
-    return a + b
-
-
-f(1, 2, b=3)
-# Raise=TypeError('f() takes 1 positional argument but 2 positional arguments (and 1 keyword-only argument) were given')

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

@@ -1,7 +0,0 @@
-# Test: unexpected keyword argument
-def f(a, b):
-    return a + b
-
-
-f(1, 2, c=3)
-# Raise=TypeError("f() got an unexpected keyword argument 'c'")

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

@@ -1,9 +0,0 @@
-# Test that heap values are properly cleaned up when unexpected kwarg error occurs
-def f(a, b):
-    return a
-
-
-# The list [1, 2, 3] should be cleaned up when the error occurs
-# because 'c' is an unexpected keyword argument
-f([1, 2, 3], [4, 5], c=[6, 7])
-# Raise=TypeError("f() got an unexpected keyword argument 'c'")

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

@@ -1,13 +0,0 @@
-def f(a):
-    pass
-
-
-f(1, **{"foo'": 2})
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "function__err_unexpected_kwarg_quote.py", line 5, in <module>
-    f(1, **{"foo'": 2})
-    ~~~~~~~~~~~~~~~~~~~
-TypeError: f() got an unexpected keyword argument 'foo''
-"""

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

@@ -1,7 +0,0 @@
-# Test: unexpected keyword argument on single-param function
-def f(a):
-    return a
-
-
-f(1, b=2)
-# Raise=TypeError("f() got an unexpected keyword argument 'b'")

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

@@ -1,6 +0,0 @@
-def f(a, b):
-    return a + b
-
-
-f(a=1, **{'a': 2})
-# Raise=TypeError("f() got multiple values for keyword argument 'a'")

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

@@ -1,8 +0,0 @@
-# Test that heap values are cleaned up when duplicate kwargs error occurs
-def f(a, b):
-    return a
-
-
-# The list value in the dict should be cleaned up when the error occurs
-f(a=[1, 2, 3], **{'a': [4, 5, 6]})
-# Raise=TypeError("f() got multiple values for keyword argument 'a'")

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

@@ -1,6 +0,0 @@
-def f(a, b):
-    return a + b
-
-
-f(1, **42)
-# Raise=TypeError('f() argument after ** must be a mapping, not int')

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

@@ -1,6 +0,0 @@
-def foo(a):
-    return a
-
-
-foo(**{1: 'value'})
-# Raise=TypeError('keywords must be strings')

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

@@ -1,6 +0,0 @@
-def f(a, b):
-    return a + b
-
-
-f(1, **[2])
-# Raise=TypeError('f() argument after ** must be a mapping, not list')

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

@@ -1,173 +0,0 @@
-# === Basic **kwargs unpacking ===
-def greet(name, greeting):
-    return f'{greeting}, {name}!'
-
-
-opts = {'greeting': 'Hi'}
-assert greet('Alice', **opts) == 'Hi, Alice!', 'basic **kwargs unpacking'
-
-# === Dict literal unpacking ===
-assert greet('Charlie', **{'greeting': 'Hey'}) == 'Hey, Charlie!', 'dict literal unpacking'
-
-
-# === Multiple kwargs in unpacked dict ===
-def format_msg(msg, prefix, suffix):
-    return f'{prefix}{msg}{suffix}'
-
-
-assert format_msg('test', **{'prefix': '[', 'suffix': ']'}) == '[test]', 'multiple kwargs unpacking'
-
-# === Combining regular kwargs with **kwargs ===
-assert format_msg('hello', prefix='> ', **{'suffix': '!'}) == '> hello!', 'regular kwargs with **kwargs'
-
-
-# === **kwargs with positional args ===
-def add_all(a, b, c):
-    return a + b + c
-
-
-assert add_all(1, 2, **{'c': 3}) == 6, '**kwargs with positional args'
-assert add_all(1, **{'b': 2, 'c': 3}) == 6, '**kwargs providing multiple args'
-
-# === Variable dict unpacking ===
-settings = {'prefix': '>>> ', 'suffix': ' <<<'}
-assert format_msg('output', **settings) == '>>> output <<<', 'variable dict unpacking'
-
-
-# === Unpacking with keyword-only args ===
-def kwonly_func(a, *, b, c):
-    return a + b + c
-
-
-assert kwonly_func(1, **{'b': 2, 'c': 3}) == 6, '**kwargs with keyword-only args'
-
-
-# === Empty dict unpacking with all args provided ===
-def simple(x, y):
-    return x + y
-
-
-assert simple(1, 2, **{}) == 3, 'empty dict unpacking'
-
-
-# === All kwargs from unpacking ===
-def all_kwargs(a, b, c):
-    return a * 100 + b * 10 + c
-
-
-assert all_kwargs(**{'a': 1, 'b': 2, 'c': 3}) == 123, 'all args from **kwargs'
-assert all_kwargs(**{'c': 7, 'a': 4, 'b': 5}) == 457, 'all args from **kwargs different order'
-
-
-# === Dynamic **kwargs keys ===
-def kwonly_echo(*, keyword):
-    return keyword
-
-
-key_name = 'k' + 'e' + 'y' + 'w' + 'o' + 'r' + 'd'
-assert kwonly_echo(**{key_name: 'dynamic'}) == 'dynamic', 'runtime string key matches kw-only param'
-
-
-# ============================================================
-# *args unpacking tests (function calls)
-# ============================================================
-
-
-# === *args with zero args ===
-def no_args():
-    return 'ok'
-
-
-assert no_args(*[]) == 'ok', '*args with empty list'
-assert no_args(*()) == 'ok', '*args with empty tuple'
-
-
-# === *args with one arg ===
-def one_arg(x):
-    return x * 2
-
-
-assert one_arg(*[5]) == 10, '*args with one item list'
-assert one_arg(*(7,)) == 14, '*args with one item tuple'
-
-
-# === *args with two args ===
-def two_args(a, b):
-    return a + b
-
-
-assert two_args(*[1, 2]) == 3, '*args with two item list'
-assert two_args(*(3, 4)) == 7, '*args with two item tuple'
-
-
-# === *args with three+ args ===
-def many_args(a, b, c, d):
-    return a + b + c + d
-
-
-assert many_args(*[1, 2, 3, 4]) == 10, '*args with four items'
-assert many_args(*(10, 20, 30, 40)) == 100, '*args with tuple four items'
-
-
-# === Mixed positional and *args ===
-assert two_args(1, *[2]) == 3, 'pos + *args'
-assert many_args(1, 2, *[3, 4]) == 10, 'two pos + *args'
-
-
-# === *args with heap-allocated values ===
-def list_arg(lst):
-    return len(lst)
-
-
-my_list = [1, 2, 3]
-assert list_arg(*[my_list]) == 3, '*args with list value'
-
-
-# ============================================================
-# Combined *args and **kwargs (function calls)
-# ============================================================
-
-
-# === *args and **kwargs together ===
-def mixed_func(a, b, c):
-    return f'{a}-{b}-{c}'
-
-
-assert mixed_func(*[1], **{'b': 2, 'c': 3}) == '1-2-3', '*args and **kwargs'
-assert mixed_func(*[1, 2], **{'c': 3}) == '1-2-3', 'two *args and **kwargs'
-
-
-# === *args tuple with **kwargs ===
-args_tuple = (10, 20)
-kwargs_dict = {'c': 30}
-assert many_args(*args_tuple, **kwargs_dict, d=40) == 100, '*args tuple + **kwargs + regular kwarg'
-
-
-# === Empty *args with **kwargs ===
-assert mixed_func(*[], **{'a': 'x', 'b': 'y', 'c': 'z'}) == 'x-y-z', 'empty *args with **kwargs'
-
-
-# === *args with empty **kwargs ===
-assert two_args(*[5, 6], **{}) == 11, '*args with empty **kwargs'
-
-
-# === All combinations: pos, *args, kwargs, **kwargs ===
-def full_func(a, b, c, d):
-    return a * 1000 + b * 100 + c * 10 + d
-
-
-assert full_func(1, *[2], c=3, **{'d': 4}) == 1234, 'pos + *args + kwarg + **kwargs'
-
-
-# === *args with heap values and **kwargs ===
-def heap_func(lst, dct):
-    return len(lst) + len(dct)
-
-
-list_val = [1, 2, 3]
-dict_val = {'a': 1}
-assert heap_func(*[list_val], **{'dct': dict_val}) == 4, '*args and **kwargs with heap values'
-
-
-# === Both *args and **kwargs empty ===
-assert no_args(*[], **{}) == 'ok', 'empty *args and empty **kwargs'

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

@@ -1,294 +0,0 @@
-# === Basic function calls ===
-def f_no_args():
-    return 1
-
-
-assert f_no_args() == 1, 'no args'
-
-
-def f_one_arg(x):
-    return x
-
-
-assert f_one_arg(42) == 42, 'one arg'
-
-
-def add(a, b):
-    return a + b
-
-
-assert add(1, 2) == 3, 'two args'
-
-
-def sum3(a, b, c):
-    return a + b + c
-
-
-assert sum3(1, 2, 3) == 6, 'three args'
-
-
-# === Local variables ===
-def f_local():
-    x = 42
-    return x
-
-
-assert f_local() == 42, 'local var'
-
-
-def f_local_from_arg(x):
-    y = x + 1
-    return y
-
-
-assert f_local_from_arg(10) == 11, 'local var from arg'
-
-
-def f_local_list():
-    items = [1, 2, 3]
-    return items
-
-
-assert f_local_list() == [1, 2, 3], 'local var list'
-
-
-def f_local_modify_list():
-    items = [1, 2]
-    items.append(3)
-    return items
-
-
-assert f_local_modify_list() == [1, 2, 3], 'local var modify list'
-
-
-def f_local_multiple():
-    a = 1
-    b = 2
-    c = 3
-    return a + b + c
-
-
-assert f_local_multiple() == 6, 'local var multiple'
-
-
-def f_local_reassign():
-    x = 1
-    x = 2
-    x = 3
-    return x
-
-
-assert f_local_reassign() == 3, 'local var reassign'
-
-
-# === Nested functions ===
-def nested_basic():
-    def bar():
-        return 1
-
-    return bar() + 1
-
-
-assert nested_basic() == 2, 'nested basic'
-
-
-def nested_deep():
-    def level2():
-        def level3():
-            return 42
-
-        return level3()
-
-    return level2()
-
-
-assert nested_deep() == 42, 'nested deep'
-
-
-def nested_multiple_calls():
-    def inner():
-        return 10
-
-    return inner() + inner() + inner()
-
-
-assert nested_multiple_calls() == 30, 'nested multiple calls'
-
-
-def nested_two_inner():
-    def add():
-        return 1
-
-    def sub():
-        return 2
-
-    return add() + sub()
-
-
-assert nested_two_inner() == 3, 'nested two inner'
-
-
-def nested_with_args(x):
-    def inner(y):
-        return y + y
-
-    return inner(x) + 1
-
-
-assert nested_with_args(5) == 11, 'nested with args'
-
-
-# === Function equality ===
-def eq_test():
-    return 1
-
-
-def eq_test2():
-    return 1
-
-
-# Same function is equal to itself
-assert eq_test == eq_test, 'function equals itself'
-assert not (eq_test != eq_test), 'function not-not-equals itself'
-
-# Different functions are not equal (even with same body)
-assert not (eq_test == eq_test2), 'different functions not equal'
-assert eq_test != eq_test2, 'different functions are not equal'
-
-# Function assigned to variable is still equal
-f_alias = eq_test
-assert f_alias == eq_test, 'function alias equals original'
-assert eq_test == f_alias, 'original equals function alias'
-
-
-# === Builtin equality ===
-# Same builtin is equal to itself
-assert len == len, 'builtin equals itself'
-assert print == print, 'print equals itself'
-assert not (len != len), 'builtin not-not-equals itself'
-
-# Builtin identity (is)
-assert print is print, 'print is print'
-assert len is len, 'len is len'
-assert not (len is print), 'len is not print'
-
-# Different builtins are not equal
-assert not (len == print), 'different builtins not equal'
-assert len != print, 'different builtins are not equal'
-
-# Builtin assigned to variable is still equal
-len_alias = len
-assert len_alias == len, 'builtin alias equals original'
-assert len_alias is len, 'builtin alias is original'
-
-
-# === Exception type equality ===
-# Note: Using == instead of 'is' to explicitly test the __eq__ implementation
-assert ValueError == ValueError, 'exc type equals itself'
-assert TypeError == TypeError, 'exc type equals itself 2'
-assert not (ValueError != ValueError), 'exc type not-not-equals itself'
-
-assert not (ValueError == TypeError), 'different exc types not equal'
-assert ValueError != TypeError, 'different exc types are not equal'
-
-exc_alias = ValueError
-assert exc_alias == ValueError, 'exc type alias equals original'
-
-
-# === Closure equality ===
-def make_adder(n):
-    def adder(x):
-        return x + n
-
-    return adder
-
-
-add1 = make_adder(1)
-add2 = make_adder(2)
-add1_again = make_adder(1)
-
-# Same closure instance equals itself
-assert add1 == add1, 'closure equals itself'
-assert not (add1 != add1), 'closure not-not-equals itself'
-
-# Different closure instances are not equal (even with same captured value)
-assert not (add1 == add1_again), 'different closure instances not equal'
-assert add1 != add1_again, 'different closure instances are not equal'
-
-# Different closure instances with different captured values
-assert not (add1 == add2), 'closures with diff captured values not equal'
-assert add1 != add2, 'closures with diff captured values are not equal'
-
-
-# === Cross-type inequality ===
-def cross_test():
-    return 1
-
-
-assert not (cross_test == len), 'function not equal to builtin'
-assert not (len == cross_test), 'builtin not equal to function'
-assert not (cross_test == ValueError), 'function not equal to exc type'
-assert not (ValueError == cross_test), 'exc type not equal to function'
-assert not (len == ValueError), 'builtin not equal to exc type'
-assert not (ValueError == len), 'exc type not equal to builtin'
-
-# Callables not equal to other types
-assert not (len == 1), 'builtin not equal to int'
-assert not (len == 'len'), 'builtin not equal to string'
-assert not (cross_test == None), 'function not equal to None'
-assert not (ValueError == None), 'exc type not equal to None'
-
-
-# === Parameter shadowing global variables ===
-# Function parameters should shadow global variables with the same name
-x = 5
-
-
-def shadow_single(x):
-    return x + 1
-
-
-# When called with 10, param x=10 should be used, not global x=5
-assert shadow_single(10) == 11, 'param shadows global - single param'
-
-y = 3
-
-
-def shadow_multiple(x, y):
-    return x + y
-
-
-# When called with (20, 30), params should be used, not globals x=5, y=3
-assert shadow_multiple(20, 30) == 50, 'param shadows global - multiple params'
-
-
-def shadow_uses_global_too(x):
-    # x is param, y is global
-    return x + y
-
-
-# x=100 (param), y=3 (global), so 100 + 3 = 103
-assert shadow_uses_global_too(100) == 103, 'param shadows but can still access other globals'
-
-
-def shadow_with_default(x=99):
-    return x + 1
-
-
-# When called with argument, param shadows global
-assert shadow_with_default(10) == 11, 'param with default shadows global'
-# When called without argument, default is used (not global)
-assert shadow_with_default() == 100, 'param default used, not global'
-
-
-# Global is still accessible outside the function
-assert x == 5, 'global still accessible after function that shadows it'
-assert y == 3, 'other global still accessible'
-
-
-# Verify global can still be used as argument
-def double(x):
-    return x * 2
-
-
-assert double(x) == 10, 'global used as argument, param shadows inside'

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

@@ -1,42 +0,0 @@
-# === Bare return statement ===
-# Test functions with bare return (no value)
-
-
-def early_exit():
-    return
-
-
-assert early_exit() is None, 'bare return returns None'
-
-
-def conditional_early_exit(x):
-    if x < 0:
-        return
-    return x * 2
-
-
-assert conditional_early_exit(-5) is None, 'conditional early return'
-assert conditional_early_exit(5) == 10, 'conditional normal return'
-
-
-def multiple_bare_returns(x):
-    if x == 0:
-        return
-    if x == 1:
-        return
-    return x
-
-
-assert multiple_bare_returns(0) is None, 'first bare return'
-assert multiple_bare_returns(1) is None, 'second bare return'
-assert multiple_bare_returns(2) == 2, 'fall through to value return'
-
-
-def nested_bare_return():
-    def inner():
-        return
-
-    return inner()
-
-
-assert nested_bare_return() is None, 'nested bare return'