superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,165 @@
+# === Type identity and repr ===
+d = {'a': 1, 'b': 2}
+
+keys = d.keys()
+items = d.items()
+values = d.values()
+
+assert type(keys).__name__ == 'dict_keys', 'dict.keys() returns a dict_keys view'
+assert type(items).__name__ == 'dict_items', 'dict.items() returns a dict_items view'
+assert type(values).__name__ == 'dict_values', 'dict.values() returns a dict_values view'
+
+assert repr(keys) == "dict_keys(['a', 'b'])", 'keys repr matches CPython'
+assert repr(items) == "dict_items([('a', 1), ('b', 2)])", 'items repr matches CPython'
+assert repr(values) == 'dict_values([1, 2])', 'values repr matches CPython'
+
+# === len() and truthiness ===
+assert len(keys) == 2, 'keys view reports live dict length'
+assert len(items) == 2, 'items view reports live dict length'
+assert len(values) == 2, 'values view reports live dict length'
+assert bool(keys) is True, 'non-empty keys view is truthy'
+assert bool(items) is True, 'non-empty items view is truthy'
+assert bool(values) is True, 'non-empty values view is truthy'
+assert bool({}.keys()) is False, 'empty keys view is falsy'
+assert bool({}.items()) is False, 'empty items view is falsy'
+assert bool({}.values()) is False, 'empty values view is falsy'
+
+# === Iteration order ===
+assert list(keys) == ['a', 'b'], 'keys iterate in insertion order'
+assert list(items) == [('a', 1), ('b', 2)], 'items iterate in insertion order'
+assert list(values) == [1, 2], 'values iterate in insertion order'
+
+# === Membership ===
+assert ('a' in keys) is True, 'keys membership checks keys'
+assert ('missing' in keys) is False, 'keys membership is false for absent keys'
+assert (('a', 1) in items) is True, 'items membership matches existing pairs'
+assert (('a', 3) in items) is False, 'items membership checks values too'
+assert (('a',) in items) is False, 'items membership ignores non-2-tuples'
+assert (1 in values) is True, 'values membership checks stored values'
+assert (3 in values) is False, 'values membership is false for absent values'
+
+try:
+    ([1], 'x') in {1: 'x'}.items()
+    assert False, 'items membership should reject unhashable keys'
+except TypeError as e:
+    assert str(e) == "cannot use 'list' as a dict key (unhashable type: 'list')", (
+        'items membership propagates key hash errors'
+    )
+
+# === Equality ===
+assert keys == keys, 'keys view equals itself'
+assert items == items, 'items view equals itself'
+assert values == values, 'values view equals itself by identity'
+
+assert keys == {'a', 'b'}, 'keys view compares equal to matching sets'
+assert {'b', 'a'} == keys, 'set equality works when dict_keys is on the right'
+assert keys == frozenset({'a', 'b'}), 'keys view compares equal to matching frozensets'
+assert frozenset({'a', 'b'}) == keys, 'frozenset equality works when dict_keys is on the right'
+assert keys == {'b': 0, 'a': 9}.keys(), 'keys view compares equal to another matching keys view'
+assert keys != {'a'}, 'keys view equality checks the full key set'
+assert keys != {'a', 'x'}, 'keys view inequality checks equal-length mismatches'
+
+assert items == {('a', 1), ('b', 2)}, 'items view compares equal to matching sets'
+assert {('b', 2), ('a', 1)} == items, 'set equality works when dict_items is on the right'
+assert items == frozenset({('a', 1), ('b', 2)}), 'items view compares equal to matching frozensets'
+assert frozenset({('a', 1), ('b', 2)}) == items, 'frozenset equality works when dict_items is on the right'
+assert items == {'b': 2, 'a': 1}.items(), 'items view compares equal to another matching items view'
+assert items != {('a', 1)}, 'items view equality checks the full item set'
+assert items != {('a', 2), ('b', 2)}, 'items view equality checks values as well as keys'
+assert items != {('a', 1), ('x', 9)}, 'items view inequality checks equal-length mismatches'
+assert ({'a': 1}.values() == {'a': 1}.values()) is False, 'distinct values views are never equal'
+
+# === Live behavior after mutation ===
+live = {'x': 10}
+live_keys = live.keys()
+live_items = live.items()
+live_values = live.values()
+live['y'] = 20
+
+assert list(live_keys) == ['x', 'y'], 'keys view sees later insertions'
+assert list(live_items) == [('x', 10), ('y', 20)], 'items view sees later insertions'
+assert list(live_values) == [10, 20], 'values view sees later insertions'
+assert repr(live_keys) == "dict_keys(['x', 'y'])", 'keys repr stays live after mutation'
+assert len(live_values) == 2, 'values len updates after mutation'
+
+# === Dict mutation during iteration ===
+changing = {'a': 1, 'b': 2}
+changing_iter = iter(changing.keys())
+assert next(changing_iter) == 'a', 'iterator yields the first key before mutation'
+changing['c'] = 3
+try:
+    next(changing_iter)
+    assert False, 'changing dict size during keys iteration should raise'
+except RuntimeError as e:
+    assert str(e) == 'dictionary changed size during iteration', 'keys iteration error matches CPython'
+
+changing = {'a': 1, 'b': 2}
+changing_iter = iter(changing.items())
+assert next(changing_iter) == ('a', 1), 'iterator yields the first item before mutation'
+changing['c'] = 3
+try:
+    next(changing_iter)
+    assert False, 'changing dict size during items iteration should raise'
+except RuntimeError as e:
+    assert str(e) == 'dictionary changed size during iteration', 'items iteration error matches CPython'
+
+changing = {'a': 1, 'b': 2}
+changing_iter = iter(changing.values())
+assert next(changing_iter) == 1, 'iterator yields the first value before mutation'
+changing['c'] = 3
+try:
+    next(changing_iter)
+    assert False, 'changing dict size during values iteration should raise'
+except RuntimeError as e:
+    assert str(e) == 'dictionary changed size during iteration', 'values iteration error matches CPython'
+
+# === dict_keys & iterable ===
+d = {'a': 1, 'b': 2, 'c': 3}
+assert d.keys() & {'b', 'c', 'x'} == {'b', 'c'}, 'keys view intersects sets'
+assert d.keys() & ('b', 'x', 'a') == {'a', 'b'}, 'keys view intersects tuples'
+assert d.keys() & iter(['c', 'c', 'a']) == {'a', 'c'}, 'keys view intersects iterators'
+assert type(d.keys() & {'a'}).__name__ == 'set', 'keys intersection returns a plain set'
+
+try:
+    d.keys() & 1
+    assert False, 'keys intersection should reject non-iterables'
+except TypeError as e:
+    assert str(e) == "'int' object is not iterable", 'non-iterable rhs error matches CPython'
+
+# === dict_keys set-like operators ===
+assert d.keys() | ('c', 'd') == {'a', 'b', 'c', 'd'}, 'keys view unions arbitrary iterables'
+assert d.keys() ^ ('b', 'd', 'e') == {'a', 'c', 'd', 'e'}, 'keys view symmetric difference works'
+assert d.keys() - ('b', 'd') == {'a', 'c'}, 'keys view difference works'
+assert d.keys() & {'b': 0, 'z': 9}.keys() == {'b'}, 'keys view intersects other keys views'
+assert d.keys() | {'c': 0, 'd': 1}.keys() == {'a', 'b', 'c', 'd'}, 'keys view unions other keys views'
+assert d.keys().isdisjoint(['x', 'y']) is True, 'keys isdisjoint accepts arbitrary iterables'
+assert d.keys().isdisjoint(iter(['x', 'a'])) is False, 'keys isdisjoint consumes iterators'
+
+# === dict_items set-like operators ===
+items_dict = {'a': 1, 'b': 2}
+assert items_dict.items() & [('a', 1), ('x', 9)] == {('a', 1)}, 'items view intersects iterables of pairs'
+assert items_dict.items() | [('c', 3)] == {('a', 1), ('b', 2), ('c', 3)}, 'items view unions iterables of pairs'
+assert items_dict.items() ^ [('a', 1), ('c', 3)] == {('b', 2), ('c', 3)}, 'items view symmetric difference works'
+assert items_dict.items() - [('a', 1)] == {('b', 2)}, 'items view difference works'
+assert items_dict.items() & {'b': 2, 'x': 9}.items() == {('b', 2)}, 'items view intersects other items views'
+assert items_dict.items().isdisjoint([('x', 1)]) is True, 'items isdisjoint accepts arbitrary iterables'
+assert items_dict.items().isdisjoint(iter([('a', 1)])) is False, 'items isdisjoint consumes iterators'
+
+# === dict_values remains non-set-like ===
+try:
+    {'a': 1}.values() & [1]
+    assert False, 'dict_values should not support set-like operators'
+except TypeError:
+    pass
+
+try:
+    {'a': 1}.values().isdisjoint([1])
+    assert False, 'dict_values should not gain isdisjoint'
+except AttributeError:
+    pass
+
+# === Motivating milestone example ===
+me_map = {'me': 1, 'you': 2, 'merve': 3}
+merve_set = {'merve', 'unknown'}
+common_ids = me_map.keys() & merve_set
+assert common_ids == {'merve'}, 'dict_keys & set supports the motivating use case'

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

@@ -0,0 +1,26 @@
+# === Empty container lengths ===
+assert (len([]), len(()), len('')) == (0, 0, 0), 'all empty lengths'
+
+# === Large concatenations ===
+lst = []
+for i in range(100):
+    lst += [i]
+assert len(lst) == 100, 'large list concat'
+
+s = ''
+for i in range(100):
+    s += 'x'
+assert len(s) == 100, 'large string concat'
+
+# === Self-concatenation ===
+lst = [1]
+lst += lst
+lst += lst
+assert lst == [1, 1, 1, 1], 'list self concat twice'
+
+# === Mod comparison in loop ===
+count = 0
+for i in range(100):
+    if i % 7 == 0:
+        count += 1
+assert count == 15, 'mod comparison chain'

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

@@ -0,0 +1,2 @@
+7.5 % 2
+# Return=1.5

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

@@ -0,0 +1,2 @@
+7 % 2.5
+# Return=2.0

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

@@ -0,0 +1,16 @@
+# === Exception .args attribute ===
+try:
+    raise ValueError('test message')
+except ValueError as e:
+    assert e.args == ('test message',), 'args is tuple with message'
+    assert e.args[0] == 'test message', 'args[0] is the message'
+
+try:
+    raise ValueError()
+except ValueError as e:
+    assert e.args == (), 'no-arg exception has empty args'
+
+try:
+    raise TypeError('type error')
+except TypeError as e:
+    assert e.args[0] == 'type error', 'works for other exception types'

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

@@ -0,0 +1,15 @@
+try:
+    raise ValueError
+except ValueError as e:
+    assert str(e) == ''
+    assert repr(e) == 'ValueError()'
+else:
+    raise AssertionError('should raise an error')
+
+try:
+    raise ValueError()
+except ValueError as e:
+    assert str(e) == ''
+    assert repr(e) == 'ValueError()'
+else:
+    raise AssertionError('should raise an error')

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

@@ -0,0 +1,54 @@
+# === Basic arithmetic ===
+assert 1 + 1 == 2, 'add ints'
+assert 'a' + 'b' == 'ab', 'add strs'
+
+# === Equality tests ===
+assert (1 == 1) == True, 'ints equal true'
+assert (1 == 2) == False, 'ints equal false'
+assert ('a' == 'a') == True, 'str equal'
+assert ('a' == 'b') == False, 'str not equal'
+assert ([1, 2] == [1, 2]) == True, 'list equal'
+assert ((1, 2) == (1, 2)) == True, 'tuple equal'
+assert (b'hello' == b'hello') == True, 'bytes equal'
+
+# === Boolean repr/str ===
+assert repr(True) == 'True', 'bool true repr'
+assert str(True) == 'True', 'bool true str'
+assert repr(False) == 'False', 'bool false repr'
+assert str(False) == 'False', 'bool false str'
+
+# === None repr/str ===
+assert repr(None) == 'None', 'none repr'
+assert str(None) == 'None', 'none str'
+
+# === Ellipsis repr/str ===
+assert repr(...) == 'Ellipsis', 'ellipsis repr'
+assert str(...) == 'Ellipsis', 'ellipsis str'
+
+# === List repr/str ===
+assert repr([1, 2]) == '[1, 2]', 'list repr'
+assert str([1, 2]) == '[1, 2]', 'list str'
+
+# === Discard expression result ===
+a = 1
+[1, 2, 3]  # this list is created and discarded
+assert a == 1, 'discard list'
+
+# === Shared list append ===
+a = [1]
+b = a
+b.append(2)
+assert len(a) == 2, 'shared list append'
+
+# === For loop string append ===
+v = ''
+for i in range(1000):
+    if i % 13 == 0:
+        v = v + 'x'
+assert len(v) == 77, 'for loop str append assign'
+
+v = ''
+for i in range(1000):
+    if i % 13 == 0:
+        v += 'x'
+assert len(v) == 77, 'for loop str append assign op'

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

@@ -0,0 +1,2 @@
+raise ValueError('testing')
+# Raise=ValueError('testing')

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

@@ -0,0 +1,2 @@
+raise TypeError()
+# Raise=TypeError()

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

@@ -0,0 +1,2 @@
+raise TypeError('hello')
+# Raise=TypeError('hello')

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

@@ -0,0 +1,2 @@
+raise TypeError("hello 'there'")
+# Raise=TypeError("hello 'there'")

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

@@ -0,0 +1,2 @@
+raise TypeError
+# Raise=TypeError()

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

@@ -0,0 +1,4 @@
+# raise exception instance stored in a variable
+a = ValueError('instance error')
+raise a
+# Raise=ValueError('instance error')

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

@@ -0,0 +1,2 @@
+raise []
+# Raise=TypeError('exceptions must derive from BaseException')

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

@@ -0,0 +1,2 @@
+raise 1 + 2
+# Raise=TypeError('exceptions must derive from BaseException')

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

@@ -0,0 +1,4 @@
+# raise exception type called via variable
+a = ValueError
+raise a('error message')
+# Raise=ValueError('error message')

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

@@ -0,0 +1,3 @@
+# raise exception type directly
+raise ValueError
+# Raise=ValueError()

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

@@ -0,0 +1,4 @@
+# raise exception type stored in a variable
+a = ValueError
+raise a
+# Raise=ValueError()

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

@@ -0,0 +1,22 @@
+# call-external
+# BUG: Side effects in arguments are duplicated when external call suspends
+#
+# When an external call is in one argument position and there's a side effect
+# in another argument position, the side effect may be executed multiple times
+# because argument evaluation is repeated during resumption.
+
+call_count = 0
+
+
+def side_effect(val):
+    global call_count
+    call_count += 1
+    return val
+
+
+# Side effect before external call in args
+# Expected: side_effect runs once, result is 10 + 3 = 13
+call_count = 0
+result = add_ints(side_effect(10), add_ints(1, 2))
+assert result == 13, 'ext call after side effect'
+assert call_count == 1, 'side effect should happen only once (before ext)'

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

@@ -0,0 +1,17 @@
+# call-external
+# External calls in augmented assignment expressions
+
+# += with external call
+x = 10
+x += add_ints(5, 5)
+assert x == 20, 'ext call in augmented add'
+
+# -= with external call
+x = 100
+x -= add_ints(20, 30)
+assert x == 50, 'ext call in augmented sub'
+
+# *= with external call
+x = 5
+x *= add_ints(2, 1)
+assert x == 15, 'ext call in augmented mul'

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

@@ -0,0 +1,7 @@
+# call-external
+# BUG: Reference counting bug with string augmented assignment and external calls
+
+# String += with external call causes reference counting error
+s = 'hello'
+s += concat_strings(' ', 'world')
+assert s == 'hello world', 'ext call in augmented string concat'

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

@@ -0,0 +1,34 @@
+# call-external
+# Test bare raise after external call resumption in except handler
+# This tests that current_exception is properly restored after resuming
+# Note: bare raise after resumption only works when exception is bound (as e)
+
+caught_reraised = False
+try:
+    try:
+        raise ValueError('original error')
+    except ValueError as e:
+        # Make an external call, which will cause a suspend/resume
+        x = add_ints(1, 2)
+        # After resuming, bare raise should still work (exception restored from binding)
+        raise
+except ValueError as outer_e:
+    caught_reraised = repr(outer_e) == "ValueError('original error')"
+
+assert caught_reraised, 'bare raise after external call should re-raise original exception'
+
+# === Nested handler bare raise after resumption ===
+outer_nested_reraise = False
+try:
+    try:
+        raise ValueError('outer error')
+    except ValueError:
+        try:
+            raise KeyError('inner error')
+        except KeyError:
+            _ = add_ints(1, 2)
+        raise
+except ValueError as reraised:
+    outer_nested_reraise = repr(reraised) == "ValueError('outer error')"
+
+assert outer_nested_reraise, 'bare raise in outer handler should re-raise original exception after nested resumption'

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

@@ -0,0 +1,99 @@
+# call-external
+# === Basic external function tests ===
+
+# Simple calls
+a = add_ints(10, 20)
+assert a == 30, 'add_ints basic'
+
+b = add_ints(-5, 15)
+assert b == 10, 'add_ints with negative'
+
+s = concat_strings('hello', ' world')
+assert s == 'hello world', 'concat_strings basic'
+
+x = return_value(42)
+assert x == 42, 'return_value with int'
+
+y = return_value('test')
+assert y == 'test', 'return_value with str'
+
+# === Assignment with external calls ===
+result = add_ints(100, 200)
+assert result == 300, 'assignment from add_ints'
+
+name = concat_strings('foo', 'bar')
+assert name == 'foobar', 'assignment from concat_strings'
+
+# === Nested calls ===
+nested = add_ints(1, add_ints(2, 3))
+assert nested == 6, 'nested add_ints right'
+
+nested2 = add_ints(add_ints(1, 2), 3)
+assert nested2 == 6, 'nested add_ints left'
+
+nested3 = add_ints(add_ints(1, 2), add_ints(3, 4))
+assert nested3 == 10, 'nested add_ints both'
+
+deep = add_ints(add_ints(add_ints(1, 2), 3), 4)
+assert deep == 10, 'deeply nested add_ints'
+
+# === Chained operations ===
+chained = add_ints(1, 2) + add_ints(3, 4)
+assert chained == 10, 'chained add_ints with +'
+
+chained2 = add_ints(10, 20) - add_ints(5, 10)
+assert chained2 == 15, 'chained add_ints with -'
+
+chained3 = add_ints(2, 3) * add_ints(4, 5)
+assert chained3 == 45, 'chained add_ints with *'
+
+str_chain = concat_strings('a', 'b') + concat_strings('c', 'd')
+assert str_chain == 'abcd', 'chained concat_strings'
+
+# === External calls in assert statements ===
+assert add_ints(5, 5) == 10, 'ext call in assert condition'
+assert return_value(True), 'ext call returning truthy in assert'
+assert concat_strings('x', 'y') == 'xy', 'concat in assert'
+assert add_ints(1, add_ints(2, 3)) == 6, 'nested ext call in assert'
+
+# === Mixed with builtins ===
+length = len(concat_strings('hello', 'world'))
+assert length == 10, 'len of concat result'
+
+items = [add_ints(1, 2), add_ints(3, 4)]
+assert items[0] == 3, 'ext call in list literal first'
+assert items[1] == 7, 'ext call in list literal second'
+
+# === Multiple external calls in single expression ===
+
+# Two ext calls added together
+sum_result = add_ints(1, 2) + add_ints(3, 4)
+assert sum_result == 10, 'two ext calls in addition'
+
+# Three ext calls in one expression
+triple = add_ints(1, 1) + add_ints(2, 2) + add_ints(3, 3)
+assert triple == 12, 'three ext calls in expression'
+
+# Ext calls in multiplication
+mul_result = add_ints(2, 3) * add_ints(1, 1)
+assert mul_result == 10, 'ext calls in multiplication'
+
+# Ext calls in subtraction
+sub_result = add_ints(10, 5) - add_ints(3, 2)
+assert sub_result == 10, 'ext calls in subtraction'
+
+# Complex expression with multiple ext calls
+complex_expr = (add_ints(1, 2) + add_ints(3, 4)) * add_ints(0, 2)
+assert complex_expr == 20, 'complex expr with ext calls'
+
+# String concatenation with multiple ext calls
+str_result = concat_strings(return_value('a'), return_value('b')) + concat_strings('c', 'd')
+assert str_result == 'abcd', 'multiple ext calls for string concat'
+
+# Comparison with multiple ext calls
+cmp_result = add_ints(5, 5) == add_ints(3, 7)
+assert cmp_result == True, 'comparison of two ext call results'
+
+# Nested ext calls in expression
+nested_expr = add_ints(add_ints(1, 2), add_ints(3, 4))
+assert nested_expr == 10, 'nested ext calls in expression'

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

@@ -0,0 +1,37 @@
+# call-external
+# External calls in boolean short-circuit expressions
+
+# === Basic boolean operations ===
+result = return_value(True) and return_value(42)
+assert result == 42, 'ext call in and (both run)'
+
+result = return_value(False) and return_value(42)
+assert result == False, 'ext call in and (short circuit)'
+
+result = return_value(0) or return_value(42)
+assert result == 42, 'ext call in or (both run)'
+
+result = return_value(99) or return_value(42)
+assert result == 99, 'ext call in or (short circuit)'
+
+
+# === Chained boolean with external calls ===
+result = return_value(True) and return_value(True) and return_value(42)
+assert result == 42, 'chained and all truthy'
+
+result = return_value(True) and return_value(False) and return_value(42)
+assert result == False, 'chained and with false in middle'
+
+result = return_value(0) or return_value(0) or return_value(42)
+assert result == 42, 'chained or all falsy except last'
+
+result = return_value(0) or return_value(99) or return_value(42)
+assert result == 99, 'chained or with truthy in middle'
+
+
+# === Mixed and/or ===
+result = return_value(True) and return_value(0) or return_value(42)
+assert result == 42, 'and then or'
+
+result = return_value(0) or return_value(True) and return_value(42)
+assert result == 42, 'or then and'

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

@@ -0,0 +1,17 @@
+# call-external
+# BUG: This test hangs (infinite loop) - external calls in boolean expressions
+# with side effects cause incorrect behavior.
+
+call_count = 0
+
+
+def side_effect(val):
+    global call_count
+    call_count += 1
+    return val
+
+
+# This specific pattern causes a hang in Monty
+result = return_value(True) and return_value(side_effect(42))
+assert result == 42, 'and: second runs when first truthy'
+assert call_count == 1, 'and: side effect runs when first is truthy'

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

@@ -0,0 +1,16 @@
+# call-external
+# BUG: External calls in closures cannot access captured variables
+# When an external call is inside a closure, it fails to access free variables
+# Error: "cannot access free variable 'x' where it is not associated with a value"
+
+
+def make_adder(x):
+    def adder(y):
+        return add_ints(x, y)
+
+    return adder
+
+
+add5 = make_adder(5)
+result = add5(10)
+assert result == 15, 'ext call in closure accessing captured var'

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

@@ -0,0 +1,26 @@
+# call-external
+# External calls in comparison expressions
+
+# External call on left side of comparison
+result = add_ints(1, 2) == 3
+assert result == True, 'ext call == literal'
+
+# External call on right side
+result = 3 == add_ints(1, 2)
+assert result == True, 'literal == ext call'
+
+# Both sides external calls
+result = add_ints(1, 2) == add_ints(2, 1)
+assert result == True, 'ext call == ext call'
+
+# Less than
+result = add_ints(1, 1) < add_ints(2, 2)
+assert result == True, 'ext call < ext call'
+
+# Greater than
+result = add_ints(5, 5) > add_ints(2, 2)
+assert result == True, 'ext call > ext call'
+
+# Not equal
+result = add_ints(1, 2) != add_ints(3, 4)
+assert result == True, 'ext call != ext call'

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

@@ -0,0 +1,18 @@
+# call-external
+# External function calls in deep call stacks (function calling function).
+# Tests that the outer function receives the return value correctly when
+# the inner function makes an external call.
+
+
+def depth1(n):
+    return add_ints(n, 1)
+
+
+def depth2(n):
+    return depth1(n) + 10
+
+
+result = depth2(5)
+# depth2(5) should be: depth1(5) + 10 = 6 + 10 = 16
+
+assert result == 16, f'ext call through 2 levels of functions {result=}'