superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,47 @@
+# === Basic functions ===
+def simple(a, b, c):
+    return a + b + c
+
+
+assert simple(1, 2, 3) == 6, 'simple function'
+assert simple(10, 20, 30) == 60, 'simple function with larger values'
+
+
+# === Positional-only parameters ===
+def pos_only(a, b, /, c):
+    return a + b + c
+
+
+assert pos_only(1, 2, 3) == 6, 'positional-only params'
+assert pos_only(5, 5, 5) == 15, 'positional-only all same'
+assert pos_only(5, 5, c=5) == 15, 'positional-only all same'
+
+
+# === All positional-only ===
+def all_pos_only(a, b, c, /):
+    return a + b + c
+
+
+assert all_pos_only(1, 2, 3) == 6, 'all positional-only'
+
+
+# === Multiple parameter groups ===
+def multi_group(a, /, b, c):
+    return f'a={a} b={b} c={c}'
+
+
+assert multi_group(1, 2, 3) == 'a=1 b=2 c=3', 'mixed positional-only and regular'
+assert multi_group(1, b=2, c=3) == 'a=1 b=2 c=3', 'mixed positional-only and regular'
+assert multi_group(1, c=3, b=2) == 'a=1 b=2 c=3', 'mixed positional-only and regular'
+
+
+# === Call-site *args unpacking ===
+def collect_all(*values):
+    return values
+
+
+source_tuple = (1, 2, 3)
+assert collect_all(*source_tuple) == (1, 2, 3), 'tuple unpacked with *args'
+
+source_list = [4, 5]
+assert collect_all(0, *source_list) == (0, 4, 5), 'positional args followed by *args'

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

@@ -0,0 +1,6 @@
+def f(a, b, c):
+    return a + b + c
+
+
+f()
+# Raise=TypeError("f() missing 3 required positional arguments: 'a', 'b', and 'c'")

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

@@ -0,0 +1,6 @@
+def f(x):
+    return x
+
+
+f()
+# Raise=TypeError("f() missing 1 required positional argument: 'x'")

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

@@ -0,0 +1,6 @@
+def f(a, b):
+    return a + b
+
+
+f(1)
+# Raise=TypeError("f() missing 1 required positional argument: 'b'")

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

@@ -0,0 +1,6 @@
+def f(x):
+    return x
+
+
+f(1, 2)
+# Raise=TypeError('f() takes 1 positional argument but 2 were given')

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

@@ -0,0 +1,6 @@
+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__too_many_args_zero.py

@@ -0,0 +1,6 @@
+def f():
+    return 1
+
+
+f(42)
+# Raise=TypeError('f() takes 0 positional arguments but 1 was given')

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

@@ -0,0 +1,7 @@
+def f():
+    x = 1
+    global x  # type: ignore[reportAssignmentBeforeGlobalDeclaration]
+
+
+f()
+# Raise=SyntaxError("name 'x' is assigned to before global declaration")

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

@@ -0,0 +1,163 @@
+# === Basic global read/write ===
+x1 = 42
+
+
+def read_explicit():
+    global x1
+    return x1
+
+
+assert read_explicit() == 42, 'explicit global read'
+
+
+x2 = 1
+
+
+def write_explicit():
+    global x2
+    x2 = 2
+
+
+write_explicit()
+assert x2 == 2, 'explicit global write'
+
+
+x3 = 42
+
+
+def read_implicit():
+    return x3  # no local x3, reads global
+
+
+assert read_implicit() == 42, 'implicit global read'
+
+
+# === Multiple functions sharing global ===
+counter1 = 0
+
+
+def inc():
+    global counter1
+    counter1 = counter1 + 1
+
+
+def get_counter():
+    return counter1
+
+
+inc()
+inc()
+assert get_counter() == 2, 'multiple functions sharing global'
+
+
+# === Mutating global containers (no 'global' needed) ===
+data1 = {'a': 1}
+
+
+def add_dict_entry():
+    data1['b'] = 2
+
+
+add_dict_entry()
+assert data1 == {'a': 1, 'b': 2}, 'mutate global dict'
+
+
+items1 = [1, 2]
+
+
+def append_list_item():
+    items1.append(3)
+
+
+append_list_item()
+assert items1 == [1, 2, 3], 'mutate global list append'
+
+
+items2 = ['a', 'c']
+
+
+def insert_list_item():
+    items2.insert(1, 'b')
+
+
+insert_list_item()
+assert items2 == ['a', 'b', 'c'], 'mutate global list insert'
+
+
+items3 = []
+
+
+def build_list():
+    items3.append(1)
+    items3.append(2)
+    items3.append(3)
+
+
+build_list()
+assert items3 == [1, 2, 3], 'mutate global list multiple'
+
+
+# === Reassigning global containers (requires 'global') ===
+items4 = [1, 2]
+
+
+def replace_list():
+    global items4
+    items4 = [3, 4, 5]
+
+
+replace_list()
+assert items4 == [3, 4, 5], 'reassign global list'
+
+
+# === Nested functions with global ===
+x4 = 1
+
+
+def outer_global():
+    def inner():
+        global x4
+        x4 = 10
+
+    inner()
+
+
+outer_global()
+assert x4 == 10, 'nested inner global write'
+
+
+x5 = 42
+
+
+def outer_read():
+    def inner():
+        return x5  # reads global
+
+    return inner()
+
+
+assert outer_read() == 42, 'nested inner global read'
+
+
+# === Shadowing ===
+x6 = 10
+
+
+def shadow_local():
+    x6 = 20  # creates local (shadows global)
+    return x6
+
+
+assert shadow_local() == 20, 'local shadows global'
+
+
+x7 = 10
+
+
+def shadow_unchanged():
+    x7 = 99  # local
+    return x7
+
+
+assert shadow_unchanged() == 99, 'shadowing returns local'
+assert x7 == 10, 'global unchanged after shadowing'

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

@@ -0,0 +1,2 @@
+hash({})
+# Raise=TypeError("unhashable type: 'dict'")

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

@@ -0,0 +1,2 @@
+hash([1, 2, 3])
+# Raise=TypeError("unhashable type: 'list'")

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

@@ -0,0 +1,153 @@
+# === Hash returns int type ===
+assert isinstance(hash(42), int), 'hash returns int type'
+assert isinstance(hash('hello'), int), 'hash of str returns int'
+assert isinstance(hash((1, 2, 3)), int), 'hash of tuple returns int'
+assert isinstance(hash(3.14), int), 'hash of float returns int'
+
+# === Hash consistency for same values ===
+assert hash(42) == hash(42), 'int hash consistent'
+assert hash(-1) == hash(-1), 'negative int hash consistent'
+assert hash(0) == hash(0), 'zero hash consistent'
+assert hash('hello') == hash('hello'), 'str hash consistent'
+assert hash('') == hash(''), 'empty str hash consistent'
+assert hash(b'hello') == hash(b'hello'), 'bytes hash consistent'
+assert hash(b'') == hash(b''), 'empty bytes hash consistent'
+assert hash(None) == hash(None), 'None hash consistent'
+assert hash(True) == hash(True), 'True hash consistent'
+assert hash(False) == hash(False), 'False hash consistent'
+assert hash((1, 2, 3)) == hash((1, 2, 3)), 'tuple hash consistent'
+assert hash(()) == hash(()), 'empty tuple hash consistent'
+assert hash((1,)) == hash((1,)), 'single element tuple hash consistent'
+assert hash(3.14) == hash(3.14), 'float hash consistent'
+assert hash(0.0) == hash(0.0), 'zero float hash consistent'
+assert hash(-0.0) == hash(-0.0), 'negative zero float hash consistent'
+assert hash(...) == hash(...), 'ellipsis hash consistent'
+
+# === Range hash consistency ===
+assert hash(range(10)) == hash(range(10)), 'range hash consistent'
+assert hash(range(0)) == hash(range(0)), 'empty range hash consistent'
+assert hash(range(1, 10)) == hash(range(1, 10)), 'range with start hash consistent'
+assert hash(range(1, 10, 2)) == hash(range(1, 10, 2)), 'range with step hash consistent'
+assert hash(range(-5, 5)) == hash(range(-5, 5)), 'negative start range hash consistent'
+
+# === Different range values should hash differently ===
+assert hash(range(10)) != hash(range(11)), 'different range stop hashes differently'
+assert hash(range(10)) != hash(range(1, 10)), 'range with different start hashes differently'
+assert hash(range(10)) != hash(range(0, 10, 2)), 'range with step hashes differently'
+assert hash(range(1, 10, 2)) != hash(range(1, 10, 3)), 'different steps hash differently'
+
+# === Different values should hash differently ===
+assert hash(1) != hash(2), 'different ints hash differently'
+assert hash('a') != hash('b'), 'different strs hash differently'
+assert hash(b'a') != hash(b'b'), 'different bytes hash differently'
+assert hash((1, 2)) != hash((1, 3)), 'different tuples hash differently'
+assert hash((1, 2)) != hash((2, 1)), 'tuple order matters for hash'
+assert hash(True) != hash(False), 'True and False hash differently'
+assert hash(3.14) != hash(2.71), 'different floats hash differently'
+
+# === Type differentiation for clearly different types ===
+assert hash(()) != hash(''), 'empty tuple and empty str hash differently'
+assert hash('1') != hash(1), 'str "1" and int 1 hash differently'
+assert hash(b'1') != hash(1), 'bytes b"1" and int 1 hash differently'
+
+# === Nested tuple hashing ===
+assert hash((1, (2, 3))) == hash((1, (2, 3))), 'nested tuple hash consistent'
+assert hash((1, (2, 3))) != hash((1, (2, 4))), 'nested tuples with different inner values hash differently'
+assert hash(((1, 2), (3, 4))) == hash(((1, 2), (3, 4))), 'tuple of tuples hash consistent'
+
+# === String/bytes content equality across representations ===
+# Interned strings and heap strings with same content should hash the same
+s1 = 'test'
+s2 = 'te' + 'st'
+assert hash(s1) == hash(s2), 'concatenated string hashes same as literal'
+
+b1 = b'test'
+b2 = b'te' + b'st'
+assert hash(b1) == hash(b2), 'concatenated bytes hashes same as literal'
+
+
+# === Function hashing ===
+def f():
+    pass
+
+
+def g():
+    pass
+
+
+assert hash(f) == hash(f), 'function hash consistent'
+assert hash(g) == hash(g), 'different function hash consistent'
+assert hash(f) != hash(g), 'different functions hash differently'
+
+# === Builtin function hashing ===
+assert hash(len) == hash(len), 'builtin hash consistent'
+assert hash(print) == hash(print), 'print builtin hash consistent'
+assert hash(len) != hash(print), 'different builtins hash differently'
+
+# === Builtin type hashing ===
+assert hash(int) == hash(int), 'int type hash consistent'
+assert hash(str) == hash(str), 'str type hash consistent'
+assert hash(int) != hash(str), 'different types hash differently'
+assert hash(int) != hash(float), 'int and float types hash differently'
+
+# === Exception type hashing ===
+assert hash(ValueError) == hash(ValueError), 'exception type hash consistent'
+assert hash(TypeError) == hash(TypeError), 'TypeError hash consistent'
+assert hash(ValueError) != hash(TypeError), 'different exception types hash differently'
+
+# === Dict key behavior with hashes ===
+# Verify that hash consistency works with dict lookups
+d = {}
+d[42] = 'int'
+d['hello'] = 'str'
+d[(1, 2)] = 'tuple'
+d[range(5)] = 'range'
+d[3.14] = 'float'
+d[None] = 'none'
+
+assert d[42] == 'int', 'int dict key works'
+assert d['hello'] == 'str', 'str dict key works'
+assert d[(1, 2)] == 'tuple', 'tuple dict key works'
+assert d[range(5)] == 'range', 'range dict key works'
+assert d[3.14] == 'float', 'float dict key works'
+assert d[None] == 'none', 'None dict key works'
+
+# === Multiple ranges as dict keys ===
+rd = {}
+rd[range(5)] = 'a'
+rd[range(10)] = 'b'
+rd[range(1, 5)] = 'c'
+rd[range(0, 5, 2)] = 'd'
+
+assert rd[range(5)] == 'a', 'range(5) key retrieval'
+assert rd[range(10)] == 'b', 'range(10) key retrieval'
+assert rd[range(1, 5)] == 'c', 'range(1,5) key retrieval'
+assert rd[range(0, 5, 2)] == 'd', 'range with step key retrieval'
+assert len(rd) == 4, 'all ranges stored as distinct keys'
+
+
+# === Functions as dict keys ===
+def key_fn():
+    pass
+
+
+fd = {}
+fd[key_fn] = 'func_value'
+assert fd[key_fn] == 'func_value', 'function as dict key works'
+
+# === Builtins as dict keys ===
+bd = {}
+bd[len] = 'len_value'
+bd[print] = 'print_value'
+assert bd[len] == 'len_value', 'builtin len as dict key'
+assert bd[print] == 'print_value', 'builtin print as dict key'
+assert len(bd) == 2, 'different builtins are distinct keys'
+
+# === Types as dict keys ===
+td = {}
+td[int] = 'int_type'
+td[str] = 'str_type'
+td[ValueError] = 'value_error'
+assert td[int] == 'int_type', 'int type as dict key'
+assert td[str] == 'str_type', 'str type as dict key'
+assert td[ValueError] == 'value_error', 'exception type as dict key'

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

@@ -0,0 +1,3 @@
+# xfail=cpython
+id(b'test') == id(b'test')
+# Return=False

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

@@ -0,0 +1,5 @@
+# value-based identity: same value = same id
+x = 100
+y = x
+id(x) == id(y)
+# Return=True

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

@@ -0,0 +1,3 @@
+# value-based identity: same value = same identity
+1 is 1
+# Return=True

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

@@ -0,0 +1,10 @@
+# xfail=cpython
+# === Heap types may have the same id if lifetimes do not overlap ===
+# See https://docs.python.org/3/library/functions.html#id
+# for Cpython it happens to be the case that for different types they end
+# up being allocated in different memory locations, but this is not guaranteed by the language spec
+assert id([]) == id([]), 'empty list may have same id'
+assert id([]) == id({}), 'empty list may have same id as empty dict'
+assert id([]) == id((1,)), 'empty list may have same id as tuple'
+assert id((1, 2)) == id((1, 2)), 'non-empty tuple may have same id'
+assert id([1, 2]) == id([1, 2]), 'non-empty list may have same id'

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

@@ -0,0 +1,6 @@
+# === Heap types may have the same id if lifetimes do not overlap ===
+# See https://docs.python.org/3/library/functions.html#id
+assert id([]) == id([]), 'empty list may have same id'
+assert id({}) == id({}), 'empty dict may have same id'
+assert id((1, 2)) == id((1, 2)), 'non-empty tuple may have same id'
+assert id([1, 2]) == id([1, 2]), 'non-empty list may have same id'

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

@@ -0,0 +1,97 @@
+# === id() returns int type ===
+assert isinstance(id(None), int), 'id returns int type'
+assert isinstance(id([]), int), 'id of list returns int'
+assert isinstance(id('hello'), int), 'id of str returns int'
+assert isinstance(id(42), int), 'id of int returns int'
+
+# === Identity operator (is) ===
+assert (True is True) == True, 'is True'
+assert (False is False) == True, 'is False'
+assert (None is None) == True, 'is None'
+assert (... is ...) == True, 'is Ellipsis'
+
+# === Identity operator (is not) ===
+assert (True is not True) == False, 'is not True'
+assert (True is not False) == True, 'is not False'
+
+# === Singleton identity ===
+assert id(None) == id(None), 'None singleton'
+assert id(True) == id(True), 'True singleton'
+assert id(False) == id(False), 'False singleton'
+assert id(...) == id(...), 'Ellipsis singleton'
+
+# bool and int are distinct
+assert id(True) != id(1), 'True is not 1'
+assert id(False) != id(0), 'False is not 0'
+
+# distinct singletons
+assert id(None) != id(True), 'None is not True'
+assert id(None) != id(False), 'None is not False'
+assert id(None) != id(...), 'None is not Ellipsis'
+
+# === Integer identity ===
+assert id(10) != id(20), 'different ints distinct'
+
+# === Float identity ===
+assert id(1.0) != id(2.0), 'different floats distinct'
+
+# === List assignment shares identity ===
+lst = [1, 2]
+ref = lst
+assert id(lst) == id(ref), 'list assignment shared'
+assert lst is ref, 'list is same'
+
+# === Variable identity is stable ===
+lst = [1, 2]
+assert id(lst) == id(lst), 'var id stable'
+
+# === List mutation preserves identity ===
+a = [1, 2]
+b = a
+b.append(3)
+assert a is b, 'list mutate preserves identity'
+
+# === Mixed types have distinct ids ===
+assert id(1) != id('1'), 'int vs str distinct'
+
+# === Tuple singleton is guaranteed to have a unique id ===
+assert id([]) != id(()), 'list vs tuple singleton distinct'
+assert id({}) != id(()), 'dict vs tuple singleton distinct'
+assert id(1) != id(()), 'int vs tuple singleton distinct'
+
+# === Multiple refs share id ===
+x = [1, 2]
+y = x
+z = y
+assert id(x) == id(y), 'multiple refs share id xy'
+assert id(y) == id(z), 'multiple refs share id yz'
+
+# === String assignment shares identity ===
+s = 'hello'
+r = s
+assert id(s) == id(r), 'str assignment shared'
+
+# === Bytes assignment shares identity ===
+b = b'hello'
+r = b
+assert id(b) == id(r), 'bytes assignment shared'
+
+# === Tuple assignment shares identity ===
+t = (1, 2)
+r = t
+assert id(t) == id(r), 'tuple assignment shared'
+
+# === Boolean is tests ===
+assert (True is True) == True, 'bool is test'
+assert (False is False) == True, 'bool is test 2'
+
+# === Array is test ===
+a = [1, 2]
+b = a
+assert (a is b) == True, 'array is test'
+assert (a is [1, 2]) == False, 'array is new literal'
+
+# === None is tests ===
+x = None
+assert (x is None) == True, 'var is None'
+assert (1 is None) == False, 'int is not None'

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

@@ -0,0 +1,3 @@
+# With string interning, identical literals have the same id
+id('hello') == id('hello')
+# Return=True