superacli 1.1.6 → 1.1.8

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

@@ -1,165 +0,0 @@
-# === 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

@@ -1,26 +0,0 @@
-# === 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

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

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

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

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

@@ -1,16 +0,0 @@
-# === 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

@@ -1,15 +0,0 @@
-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

@@ -1,54 +0,0 @@
-# === 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

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +0,0 @@
-# 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

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

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

@@ -1,2 +0,0 @@
-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

@@ -1,4 +0,0 @@
-# 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

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

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

@@ -1,4 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-# 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

@@ -1,7 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-# 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

@@ -1,99 +0,0 @@
-# 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

@@ -1,37 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-# 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

@@ -1,16 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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=}'