superacli 1.1.5 → 1.1.7

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

@@ -1,178 +0,0 @@
-# === Construction ===
-fs = frozenset()
-assert len(fs) == 0, 'empty frozenset len'
-assert fs == frozenset(), 'empty frozenset equality'
-
-fs = frozenset([1, 2, 3])
-assert len(fs) == 3, 'frozenset from list len'
-
-# === Copy ===
-fs = frozenset([1, 2, 3])
-fs2 = fs.copy()
-assert fs == fs2, 'copy equality'
-
-# === Union ===
-fs1 = frozenset([1, 2])
-fs2 = frozenset([2, 3])
-u = fs1.union(fs2)
-assert len(u) == 3, 'union len'
-
-# === Intersection ===
-fs1 = frozenset([1, 2, 3])
-fs2 = frozenset([2, 3, 4])
-i = fs1.intersection(fs2)
-assert len(i) == 2, 'intersection len'
-
-# === Difference ===
-fs1 = frozenset([1, 2, 3])
-fs2 = frozenset([2, 3, 4])
-d = fs1.difference(fs2)
-assert len(d) == 1, 'difference len'
-
-# === Symmetric Difference ===
-fs1 = frozenset([1, 2, 3])
-fs2 = frozenset([2, 3, 4])
-sd = fs1.symmetric_difference(fs2)
-assert len(sd) == 2, 'symmetric_difference len'
-
-# === Binary operators ===
-fs = frozenset([1, 2])
-other_fs = frozenset([2, 3])
-s = {2, 3}
-
-assert fs & other_fs == frozenset([2]), 'frozenset & frozenset works'
-assert fs | other_fs == frozenset([1, 2, 3]), 'frozenset | frozenset works'
-assert fs ^ other_fs == frozenset([1, 3]), 'frozenset ^ frozenset works'
-assert fs - other_fs == frozenset([1]), 'frozenset - frozenset works'
-
-assert fs & s == frozenset([2]), 'frozenset & set works'
-assert fs | s == frozenset([1, 2, 3]), 'frozenset | set works'
-assert fs ^ s == frozenset([1, 3]), 'frozenset ^ set works'
-assert fs - s == frozenset([1]), 'frozenset - set works'
-
-keys = {'a': 1, 'b': 2}.keys()
-items = {'a': 1, 'b': 2}.items()
-assert frozenset({'a'}) & keys == frozenset({'a'}), 'frozenset & dict_keys works'
-assert frozenset({'a'}) | keys == frozenset({'a', 'b'}), 'frozenset | dict_keys works'
-assert frozenset({('a', 1)}) ^ items == frozenset({('b', 2)}), 'frozenset ^ dict_items works'
-assert frozenset({('a', 1), ('b', 2)}) - items == frozenset(), 'frozenset - dict_items works'
-
-assert type(fs | s).__name__ == 'frozenset', 'frozenset operators keep the left operand type'
-
-try:
-    fs & [1, 2]
-    assert False, 'frozenset operators reject non-set rhs'
-except TypeError as e:
-    assert str(e) == "unsupported operand type(s) for &: 'frozenset' and 'list'", (
-        'frozenset & rhs error matches CPython'
-    )
-
-# === Issubset ===
-fs1 = frozenset([1, 2])
-fs2 = frozenset([1, 2, 3])
-assert fs1.issubset(fs2) == True, 'issubset true'
-assert fs2.issubset(fs1) == False, 'issubset false'
-
-# === Issuperset ===
-fs1 = frozenset([1, 2, 3])
-fs2 = frozenset([1, 2])
-assert fs1.issuperset(fs2) == True, 'issuperset true'
-assert fs2.issuperset(fs1) == False, 'issuperset false'
-
-# === Isdisjoint ===
-fs1 = frozenset([1, 2])
-fs2 = frozenset([3, 4])
-fs3 = frozenset([2, 3])
-assert fs1.isdisjoint(fs2) == True, 'isdisjoint true'
-assert fs1.isdisjoint(fs3) == False, 'isdisjoint false'
-
-# === Bool ===
-assert bool(frozenset()) == False, 'empty frozenset is falsy'
-assert bool(frozenset([1])) == True, 'non-empty frozenset is truthy'
-
-# === repr ===
-assert repr(frozenset()) == 'frozenset()', 'empty frozenset repr'
-
-# === Hashing ===
-fs = frozenset([1, 2, 3])
-h = hash(fs)
-assert isinstance(h, int), 'frozenset hash is int'
-
-# Same elements should have same hash
-fs1 = frozenset([1, 2, 3])
-fs2 = frozenset([3, 2, 1])  # Different order
-assert hash(fs1) == hash(fs2), 'frozenset hash is order-independent'
-
-# === As dict key ===
-d = {}
-fs = frozenset([1, 2])
-d[fs] = 'value'
-assert d[fs] == 'value', 'frozenset as dict key'
-assert d[frozenset([2, 1])] == 'value', 'frozenset key lookup order-independent'
-
-# === Construction from various iterables ===
-fs = frozenset('abc')
-assert len(fs) == 3, 'frozenset from string len'
-assert 'a' in fs and 'b' in fs and 'c' in fs, 'frozenset from string elements'
-
-fs = frozenset((1, 2, 3))
-assert fs == frozenset({1, 2, 3}), 'frozenset from tuple'
-
-fs = frozenset(range(5))
-assert fs == frozenset({0, 1, 2, 3, 4}), 'frozenset from range'
-
-fs = frozenset({1, 2, 3})
-assert len(fs) == 3, 'frozenset from set'
-
-# === Containment (in / not in) ===
-fs = frozenset({1, 2, 3})
-assert 1 in fs, 'in frozenset positive'
-assert 4 not in fs, 'not in frozenset'
-assert 'x' not in frozenset({'a', 'b'}), 'not in frozenset strings'
-
-# === Iteration ===
-result = []
-for x in frozenset({1, 2, 3}):
-    result.append(x)
-assert len(result) == 3, 'frozenset iteration length'
-assert set(result) == {1, 2, 3}, 'frozenset iteration elements'
-
-result = []
-for x in frozenset():
-    result.append(x)
-assert result == [], 'empty frozenset iteration'
-
-# === Inequality (!=) ===
-assert frozenset({1, 2}) != frozenset({1, 3}), 'frozenset ne different'
-assert not (frozenset({1, 2}) != frozenset({1, 2})), 'frozenset ne same'
-
-# === Methods accepting iterables ===
-assert frozenset({1, 2}).union([3, 4]) == frozenset({1, 2, 3, 4}), 'union with list arg'
-assert frozenset({1, 2, 3}).intersection([2, 3, 4]) == frozenset({2, 3}), 'intersection with list arg'
-assert frozenset({1, 2, 3}).difference([2]) == frozenset({1, 3}), 'difference with list arg'
-assert frozenset({1, 2}).symmetric_difference([2, 3]) == frozenset({1, 3}), 'symmetric_difference with list arg'
-assert frozenset({1}).union(range(3)) == frozenset({0, 1, 2}), 'union with range arg'
-assert frozenset({1}).union((2, 3)) == frozenset({1, 2, 3}), 'union with tuple arg'
-
-# === issubset/issuperset/isdisjoint with non-set iterables ===
-fs = frozenset({1, 2, 3})
-assert fs.issubset(range(10)), 'issubset with range'
-assert fs.issuperset([1, 2]), 'issuperset with list'
-assert fs.isdisjoint([4, 5, 6]), 'isdisjoint with list'
-assert not fs.isdisjoint([3, 4]), 'not isdisjoint with list'
-
-# === Different hashes for different frozensets ===
-fs1 = frozenset({1, 2})
-fs2 = frozenset({3, 4})
-# Not guaranteed to be different, but very likely
-# Instead just verify they're integers and stable
-assert hash(fs1) == hash(frozenset({2, 1})), 'hash stable across order'
-assert hash(frozenset()) == hash(frozenset()), 'empty frozenset hash stable'
-
-# === Frozenset as set element ===
-s = {frozenset({1, 2}), frozenset({3, 4})}
-assert len(s) == 2, 'set of frozensets'
-assert frozenset({1, 2}) in s, 'frozenset element lookup'
-# Duplicate frozenset should dedup
-s2 = {frozenset({1}), frozenset({1})}
-assert len(s2) == 1, 'duplicate frozensets dedup in set'

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

@@ -1,236 +0,0 @@
-# === Basic f-strings ===
-assert f'hello' == 'hello', 'basic f-string'
-assert f'' == '', 'empty f-string'
-
-# === Simple interpolation ===
-x = 'world'
-assert f'hello {x}' == 'hello world', 'simple interpolation'
-
-# multiple interpolations
-a = 1
-b = 2
-assert f'{a} + {b} = {a + b}' == '1 + 2 = 3', 'multiple interpolations'
-
-# expression in f-string
-assert f'{1 + 2 + 3}' == '6', 'expression'
-
-# === Value types ===
-# list value
-x = [1, 2, 3]
-assert f'list: {x}' == 'list: [1, 2, 3]', 'list value'
-
-# bool value
-x = True
-assert f'value: {x}' == 'value: True', 'bool value'
-
-# int value
-assert f'{42}' == '42', 'int value'
-
-# float value
-assert f'{3.14}' == '3.14', 'float value'
-
-# None value
-assert f'{None}' == 'None', 'None value'
-
-# === Conversion flags (!s, !r, !a) ===
-# conversion !s (str)
-assert f'{42!s}' == '42', 'conversion !s'
-
-# conversion !r (repr)
-assert f'{"hello"!r}' == "'hello'", 'conversion !r'
-
-# conversion !r on int (should be same as str for int)
-assert f'{42!r}' == '42', 'conversion !r on int'
-
-# conversion !r on list
-assert f'{[1, 2]!r}' == '[1, 2]', 'conversion !r on list'
-
-# conversion !s on string (no quotes)
-assert f'{"hello"!s}' == 'hello', 'conversion !s on string'
-
-# conversion !a (ascii) - escapes non-ASCII characters
-assert f'{"café"!a}' == "'caf\\xe9'", 'conversion !a'
-assert f'{"hello"!a}' == "'hello'", 'conversion !a ascii only'
-assert f'{"日本"!a}' == "'\\u65e5\\u672c'", 'conversion !a unicode'
-
-# === String padding and alignment ===
-# format spec: width (left-aligned by default for strings)
-assert f'{"hi":10}' == 'hi        ', 'format width'
-
-# format spec: left align
-assert f'{"hi":<10}' == 'hi        ', 'format left align'
-
-# format spec: right align
-assert f'{"hi":>10}' == '        hi', 'format right align'
-
-# format spec: center align
-assert f'{"hi":^10}' == '    hi    ', 'format center align'
-
-# center align with odd padding
-assert f'{"zip":^6}' == ' zip  ', 'format center align odd'
-
-# format spec: fill character
-assert f'{"hi":*>10}' == '********hi', 'format fill right'
-assert f'{"hi":_<10}' == 'hi________', 'format fill left'
-assert f'{"hi":*^10}' == '****hi****', 'format fill center'
-
-# string truncation with precision
-assert f'{"xylophone":.5}' == 'xylop', 'string truncation'
-assert f'{"xylophone":10.5}' == 'xylop     ', 'string truncation with width'
-
-# === Integer formatting ===
-# basic integer
-assert f'{42}' == '42', 'basic integer'
-
-# integer with :d type
-assert f'{42:d}' == '42', 'integer :d'
-
-# integer padding
-assert f'{42:4d}' == '  42', 'integer padding'
-assert f'{42:04d}' == '0042', 'integer zero padding'
-
-# integer with sign
-assert f'{42:+d}' == '+42', 'integer positive sign'
-assert f'{42: d}' == ' 42', 'integer space for positive'
-assert f'{-42:+d}' == '-42', 'integer negative with sign'
-assert f'{-42: d}' == '-42', 'integer negative space'
-
-# sign-aware padding
-assert f'{-23:=5d}' == '-  23', 'sign-aware padding'
-
-# === Float formatting ===
-# basic float
-assert f'{3.14159}' == '3.14159', 'basic float'
-
-# float with :f type
-assert f'{3.141592653589793:f}' == '3.141593', 'float :f'
-
-# float precision
-assert f'{3.141592653589793:.2f}' == '3.14', 'float precision'
-assert f'{3.141592653589793:.4f}' == '3.1416', 'float precision 4'
-
-# float width and precision
-assert f'{3.141592653589793:06.2f}' == '003.14', 'float zero pad with precision'
-assert f'{3.141592653589793:10.2f}' == '      3.14', 'float width with precision'
-
-# float with sign
-assert f'{3.14:+.2f}' == '+3.14', 'float positive sign'
-assert f'{-3.14:+.2f}' == '-3.14', 'float negative with sign'
-assert f'{3.14:-.2f}' == '3.14', 'float explicit minus sign'
-assert f'{-3.14:-.2f}' == '-3.14', 'float explicit minus sign negative'
-
-# exponential notation
-assert f'{1234.5678:e}' == '1.234568e+03', 'exponential lowercase'
-assert f'{1234.5678:E}' == '1.234568E+03', 'exponential uppercase'
-assert f'{1234.5678:.2e}' == '1.23e+03', 'exponential with precision'
-assert f'{0.00012345:.2e}' == '1.23e-04', 'exponential small number'
-
-# general format (g/G) - uses exponential for very large/small numbers
-assert f'{1.5:g}' == '1.5', 'general format simple'
-assert f'{1.500:g}' == '1.5', 'general format strips trailing zeros'
-assert f'{1234567890:g}' == '1.23457e+09', 'general format large number'
-
-# percentage
-assert f'{0.25:%}' == '25.000000%', 'percentage default precision'
-assert f'{0.25:.1%}' == '25.0%', 'percentage with precision'
-assert f'{0.125:.0%}' == '12%', 'percentage zero precision'
-
-# === Nested format specs ===
-width = 10
-assert f'{"hi":{width}}' == 'hi        ', 'nested format spec width'
-
-# nested alignment and width
-align = '^'
-assert f'{"test":{align}{width}}' == '   test   ', 'nested align and width'
-
-# nested precision
-prec = 3
-assert f'{"xylophone":.{prec}}' == 'xyl', 'nested precision'
-
-
-# === f-string in function ===
-def greet(name):
-    return f'Hello, {name}!'
-
-
-assert greet('World') == 'Hello, World!', 'f-string in function'
-
-
-# function returning formatted value
-def format_num(n, w):
-    return f'{n:>{w}}'
-
-
-assert format_num('x', 5) == '    x', 'f-string with params'
-
-# === Escaping ===
-# double braces to escape
-assert f'{{}}' == '{}', 'escaped braces'
-assert f'{{x}}' == '{x}', 'escaped braces with content'
-assert f'{{{42}}}' == '{42}', 'value inside escaped braces'
-
-# === Complex expressions ===
-# TODO: method call on literal - parser doesn't support this yet
-# assert f'{"hello".upper()}' == 'HELLO', 'method call on literal'
-
-# TODO: method call on variable - str.upper() not implemented yet
-# s = 'hello'
-# assert f'{s.upper()}' == 'HELLO', 'method call on variable'
-
-# subscript in f-string
-lst = [10, 20, 30]
-assert f'{lst[1]}' == '20', 'subscript'
-
-# dict lookup
-d = {'a': 1, 'b': 2}
-assert f'{d["a"]}' == '1', 'dict lookup'
-
-# TODO: conditional expression - parser doesn't support IfExp yet
-# x = 5
-# assert f'{x if x > 0 else -x}' == '5', 'conditional positive'
-# x = -5
-# assert f'{-x if x < 0 else x}' == '5', 'conditional negative'
-
-# === String concatenation ===
-name = 'world'
-# regular string + f-string (implicit concatenation)
-assert f'hello {name}' == 'hello world', 'str concat with fstring'
-
-# === Empty interpolation expression ===
-# (this should be a syntax error, but test current behavior)
-# assert f'{}' would be syntax error
-
-# === Whitespace in format spec ===
-# no extra whitespace handling needed, width handles it
-assert f'{"x":5}' == 'x    ', 'single char width'
-
-# === Unicode character counting in padding ===
-x = 'café'
-assert f'{x:_<10}' == 'café______'
-assert f'{x:_>10}' == '______café'
-assert f'{x:_^10}' == '___café___'
-assert f'{x:_^11}' == '___café____'
-assert f'{x:é<10}' == 'cafééééééé'
-assert f'{x:é>10}' == 'éééééécafé'
-assert f'{x:é^10}' == 'ééécaféééé'
-assert f'{x:é^11}' == 'ééécafééééé'
-
-# === Conversion flag with type spec ===
-# conversion flag produces string, so 's' format should work
-assert f'{42!r:s}' == '42', 'conversion with type spec'
-
-# === Zero-padding with negative numbers ===
-# zero-padding should use sign-aware alignment
-x = -42
-assert f'{x:05d}' == '-0042', 'zero pad negative'
-
-# === Debug/self-documenting expressions (=) ===
-a = 42
-assert f'{a=}' == 'a=42', 'basic debug expression'
-assert f'{a = }' == 'a = 42', 'debug with spaces'
-name = 'test'
-assert f'{name=}' == "name='test'", 'debug uses repr for strings'
-assert f'{name = }' == "name = 'test'", 'debug uses repr for strings'
-assert f'{name=!s}' == 'name=test', 'debug with !s conversion'
-assert f'{name=!r}' == "name='test'", 'debug with !r conversion'
-assert f'{1+1=}' == '1+1=2', 'debug with expression'

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

@@ -1,3 +0,0 @@
-# '=' alignment on string raises ValueError
-f'{"hello":=10}'
-# Raise=ValueError("'=' alignment not allowed in string format specifier")

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

@@ -1,3 +0,0 @@
-# float format specifier ':f' on string raises ValueError
-f'{"hello":f}'
-# Raise=ValueError("Unknown format code 'f' for object of type 'str'")

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

@@ -1,3 +0,0 @@
-# integer format specifier ':d' on float raises ValueError
-f'{3.14:d}'
-# Raise=ValueError("Unknown format code 'd' for object of type 'float'")

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

@@ -1,3 +0,0 @@
-# integer format specifier ':d' on string raises ValueError
-f'{"hello":d}'
-# Raise=ValueError("Unknown format code 'd' for object of type 'str'")

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

@@ -1,4 +0,0 @@
-# xfail=cpython
-# invalid format specifier with trailing characters (detected at parse time)
-f'{1:10xyz}'
-# Raise=SyntaxError("Invalid format specifier '10xyz'")

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

@@ -1,4 +0,0 @@
-# invalid format specifier with dynamic spec
-spec = 'xyz'
-f'{1:{spec}}'
-# Raise=ValueError("Invalid format specifier 'xyz' for object of type 'int'")

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

@@ -1,4 +0,0 @@
-# xfail=cpython
-# invalid format specifier for string (detected at parse time)
-f'{"hello":abc}'
-# Raise=SyntaxError("Invalid format specifier 'abc'")

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

@@ -1,3 +0,0 @@
-# string format specifier ':s' on integer raises ValueError
-f'{42:s}'
-# Raise=ValueError("Unknown format code 's' for object of type 'int'")

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

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

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

@@ -1,42 +0,0 @@
-def f(*args, **kwargs):
-    return args, kwargs
-
-
-# === Multiple *args ===
-assert f(*[1, 2], *[3, 4]) == ((1, 2, 3, 4), {}), 'multiple star args'
-assert f(0, *[1, 2], 3) == ((0, 1, 2, 3), {}), 'positional after star args'
-assert f(*[], *[1]) == ((1,), {}), 'unpack empty then non-empty'
-
-# === Multiple **kwargs ===
-assert f(**{'a': 1}, **{'b': 2}) == ((), {'a': 1, 'b': 2}), 'multiple star-star kwargs'
-assert f(**{'a': 1}, b=2) == ((), {'a': 1, 'b': 2}), 'named after star-star'
-assert f(key='before', **{'a': 1}) == ((), {'key': 'before', 'a': 1}), 'named before star-star'
-
-# === Mixed ===
-assert f(1, *[2, 3], **{'x': 4}) == ((1, 2, 3), {'x': 4}), 'mixed star and star-star'
-
-# === Builtin callable with GeneralizedCall (Callable::Builtin path) ===
-# max(*[1,2], *[3,4]) exercises the Callable::Builtin branch in compile_call GeneralizedCall
-result = max(*[1, 2], *[3, 4])
-assert result == 4, 'builtin max with multiple *args'
-
-result = min(*[5, 3], *[7, 1])
-assert result == 1, 'builtin min with multiple *args'
-
-# === Expression-based callable with GeneralizedCall (compile_call_args path) ===
-# funcs[0](*[1,2], *[3,4]) exercises the GeneralizedCall branch in compile_call_args
-funcs = [f]
-result = funcs[0](*[1, 2], *[3, 4])
-assert result == ((1, 2, 3, 4), {}), 'subscript call with multiple *args'
-
-result = funcs[0](**{'a': 1}, **{'b': 2})
-assert result == ((), {'a': 1, 'b': 2}), 'subscript call with multiple **kwargs'
-
-# === Named kwarg in GeneralizedCall (compile_generalized_call_body Named path) ===
-# f(*[1,2], *[3], x=5): two *unpacks → GeneralizedCall; x=5 is a Named kwarg.
-# This exercises the CallKwarg::Named arm in compile_generalized_call_body.
-result = f(*[1, 2], *[3], x=5)
-assert result == ((1, 2, 3), {'x': 5}), 'named kwarg in multi-star GeneralizedCall'
-
-result = funcs[0](*[1, 2], *[3], x=5)
-assert result == ((1, 2, 3), {'x': 5}), 'subscript call: named kwarg in GeneralizedCall'

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

@@ -1,117 +0,0 @@
-# Tests for default parameter values in function definitions
-
-# === Basic default values ===
-def f_basic(a, b=10):
-    return a + b
-
-
-assert f_basic(1) == 11, 'default used'
-assert f_basic(1, 2) == 3, 'default overridden'
-assert f_basic(5) == 15, 'default used again'
-
-
-# === Multiple defaults ===
-def f_multi(a=1, b=2):
-    return a + b
-
-
-assert f_multi() == 3, 'both defaults'
-assert f_multi(10) == 12, 'first provided'
-assert f_multi(10, 20) == 30, 'both provided'
-
-
-# === Mixed required and default ===
-def f_mixed(a, b, c=3, d=4):
-    return a + b + c + d
-
-
-assert f_mixed(1, 2) == 10, 'required only'
-assert f_mixed(1, 2, 30) == 37, 'one default overridden'
-assert f_mixed(1, 2, 30, 40) == 73, 'all provided'
-
-
-# === Default with keyword args ===
-def f_kw(a, b=10):
-    return a + b
-
-
-assert f_kw(1, b=20) == 21, 'keyword override'
-assert f_kw(a=5) == 15, 'keyword required, default used'
-assert f_kw(a=5, b=3) == 8, 'both keywords'
-
-
-# === Default expressions evaluated at definition ===
-# Test that default is evaluated once at definition time
-def value_maker():
-    return 42
-
-
-def f_eval(x=value_maker()):
-    return x
-
-
-# value_maker was called once at function definition time
-assert f_eval() == 42, 'first call uses cached default'
-assert f_eval() == 42, 'second call uses same default'
-
-
-# === Mutable default (Python gotcha - shared across calls) ===
-def f_mutable(lst=[]):
-    lst.append(1)
-    return lst
-
-
-first_result = f_mutable()
-assert first_result == [1], 'first call'
-second_result = f_mutable()
-assert second_result == [1, 1], 'second call appends to same list'
-assert first_result is second_result, 'same list object'
-
-
-# === Multiple functions with separate defaults ===
-def f_sep1(x=[]):
-    x.append('a')
-    return x
-
-
-def f_sep2(x=[]):
-    x.append('b')
-    return x
-
-
-r1 = f_sep1()
-r2 = f_sep2()
-assert r1 == ['a'], 'f_sep1 default'
-assert r2 == ['b'], 'f_sep2 default'
-assert r1 is not r2, 'separate default lists'
-
-
-# === Default referencing earlier param (not supported, different test) ===
-
-
-# === Closure with defaults ===
-def make_adder(n):
-    def add(x, y=n):
-        return x + y
-
-    return add
-
-
-add5 = make_adder(5)
-assert add5(10) == 15, 'closure default from enclosing scope'
-assert add5(10, 3) == 13, 'closure default overridden'
-
-add10 = make_adder(10)
-assert add10(1) == 11, 'different closure, different captured default'
-
-# Verify the two closures have independent defaults
-assert add5(1) == 6, 'add5 still uses 5'
-
-
-# === Keyword-only defaults interleaved ===
-def kwonly_mix(*, head=1, mid, tail=3):
-    return head, mid, tail
-
-
-assert kwonly_mix(mid=2) == (1, 2, 3), 'kw-only defaults applied per parameter'
-assert kwonly_mix(head=5, mid=7) == (5, 7, 3), 'kw-only default overridden independently'

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

@@ -1,7 +0,0 @@
-# Test: same argument passed both positionally and by keyword
-def f(a, b, c):
-    return a + b + c
-
-
-f(1, 2, b=3)
-# Raise=TypeError("f() got multiple values for argument 'b'")

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

@@ -1,7 +0,0 @@
-# Test: first argument passed both positionally and by keyword
-def f(a, b):
-    return a + b
-
-
-f(1, a=2)
-# Raise=TypeError("f() got multiple values for argument 'a'")

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

@@ -1,9 +0,0 @@
-# Test that heap values are properly cleaned up when duplicate kwarg error occurs
-def f(a, b):
-    return a
-
-
-# The list [1, 2, 3] should be cleaned up when the error occurs
-# because 'a' is passed both positionally and by keyword
-f([1, 2, 3], a=[4, 5])
-# Raise=TypeError("f() got multiple values for argument 'a'")

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

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

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

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