superacli 1.1.6 → 1.1.8

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

@@ -1,37 +0,0 @@
-# call-external
-# External calls in if conditions
-
-
-def check_positive():
-    if add_ints(1, 2) > 0:
-        return 'positive'
-    return 'not positive'
-
-
-result = check_positive()
-assert result == 'positive', 'ext call in if condition'
-
-
-def check_with_else():
-    if add_ints(-5, 3) > 0:
-        return 'positive'
-    else:
-        return 'negative or zero'
-
-
-result = check_with_else()
-assert result == 'negative or zero', 'ext call in if condition with else'
-
-
-def check_elif():
-    val = add_ints(5, 5)
-    if val > 15:
-        return 'big'
-    elif val > 5:
-        return 'medium'
-    else:
-        return 'small'
-
-
-result = check_elif()
-assert result == 'medium', 'ext call result used in elif chain'

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

@@ -1,14 +0,0 @@
-# call-external
-# External function calls inside closures (nested functions with captured variables).
-
-
-def outer_with_nested():
-    x = 10
-
-    def inner():
-        return add_ints(x, 5)
-
-    return inner()
-
-
-assert outer_with_nested() == 15, 'ext call in nested function'

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

@@ -1,40 +0,0 @@
-# call-external
-# === External function calls inside user-defined functions ===
-
-# Basic function calling external function
-def add_wrapper(a, b):
-    return add_ints(a, b)
-
-
-result = add_wrapper(10, 20)
-assert result == 30, 'basic ext call in function'
-
-
-# Function with multiple external calls (sequential)
-def multi_ext():
-    x = add_ints(1, 2)
-    y = add_ints(3, 4)
-    return add_ints(x, y)
-
-
-assert multi_ext() == 10, 'multiple ext calls in function'
-
-
-# External call in function with local variable usage
-def with_locals():
-    x = 100
-    y = add_ints(x, 50)
-    z = y * 2
-    return z
-
-
-assert with_locals() == 300, 'ext call with locals'
-
-
-# Function returning external call result
-def get_sum(a, b, c):
-    temp = add_ints(a, b)
-    return add_ints(temp, c)
-
-
-assert get_sum(1, 2, 3) == 6, 'chained ext calls in function'

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

@@ -1,7 +0,0 @@
-# call-external
-def foo():
-    return add_ints(1, 2)
-
-
-result = foo()
-assert result == 3, 'basic ext call in function'

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

@@ -1,17 +0,0 @@
-# call-external
-# External calls in list and dict literals
-
-# External call in list literal
-lst = [add_ints(1, 2), add_ints(3, 4)]
-assert lst[0] == 3, 'ext call in list literal [0]'
-assert lst[1] == 7, 'ext call in list literal [1]'
-
-# External call in tuple literal
-tup = (add_ints(1, 1), add_ints(2, 2))
-assert tup[0] == 2, 'ext call in tuple literal [0]'
-assert tup[1] == 4, 'ext call in tuple literal [1]'
-
-# External call in dict value
-d = {'a': add_ints(5, 5), 'b': add_ints(10, 10)}
-assert d['a'] == 10, 'ext call in dict value a'
-assert d['b'] == 20, 'ext call in dict value b'

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

@@ -1,32 +0,0 @@
-# call-external
-# Multiple external calls within user-defined functions
-
-
-def compute_sum():
-    a = add_ints(1, 2)
-    b = add_ints(3, 4)
-    c = add_ints(5, 6)
-    return a + b + c
-
-
-result = compute_sum()
-assert result == 21, 'multiple sequential ext calls in func'
-
-
-def compute_nested():
-    return add_ints(add_ints(1, 2), add_ints(3, 4))
-
-
-result = compute_nested()
-assert result == 10, 'nested ext calls in func'
-
-
-def outer():
-    def inner():
-        return add_ints(10, 20)
-
-    return inner() + add_ints(1, 2)
-
-
-result = outer()
-assert result == 33, 'ext call in nested func plus outer ext call'

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

@@ -1,69 +0,0 @@
-# call-external
-# Tests for NameLookup resolution with various value types.
-# Verifies that the host can inject non-function values (constants)
-# into the sandbox namespace via the NameLookup mechanism.
-
-# === Integer constant ===
-assert CONST_INT == 42, f'CONST_INT should be 42, got {CONST_INT}'
-assert CONST_INT + 8 == 50, 'CONST_INT arithmetic'
-assert type(CONST_INT) == int, f'CONST_INT type should be int, got {type(CONST_INT)}'
-
-# === String constant ===
-assert CONST_STR == 'hello', f'CONST_STR should be hello, got {CONST_STR}'
-assert CONST_STR + ' world' == 'hello world', 'CONST_STR concatenation'
-assert len(CONST_STR) == 5, f'CONST_STR length should be 5, got {len(CONST_STR)}'
-assert type(CONST_STR) == str, f'CONST_STR type should be str, got {type(CONST_STR)}'
-
-# === Float constant ===
-assert CONST_FLOAT == 3.14, f'CONST_FLOAT should be 3.14, got {CONST_FLOAT}'
-assert CONST_FLOAT + 0.86 == 4.0, 'CONST_FLOAT arithmetic'
-assert type(CONST_FLOAT) == float, f'CONST_FLOAT type should be float, got {type(CONST_FLOAT)}'
-
-# === Boolean constant ===
-assert CONST_BOOL == True, f'CONST_BOOL should be True, got {CONST_BOOL}'
-assert CONST_BOOL and True, 'CONST_BOOL in boolean expression'
-assert type(CONST_BOOL) == bool, f'CONST_BOOL type should be bool, got {type(CONST_BOOL)}'
-
-# === List constant ===
-assert CONST_LIST == [1, 2, 3], f'CONST_LIST should be [1, 2, 3], got {CONST_LIST}'
-assert len(CONST_LIST) == 3, f'CONST_LIST length should be 3, got {len(CONST_LIST)}'
-assert CONST_LIST[0] == 1, 'CONST_LIST first element'
-assert CONST_LIST[-1] == 3, 'CONST_LIST last element'
-assert type(CONST_LIST) == list, f'CONST_LIST type should be list, got {type(CONST_LIST)}'
-
-# === None constant ===
-assert CONST_NONE is None, f'CONST_NONE should be None, got {CONST_NONE}'
-assert type(CONST_NONE) == type(None), f'CONST_NONE type should be NoneType, got {type(CONST_NONE)}'
-
-# === Caching: same constant used twice should work ===
-x = CONST_INT
-y = CONST_INT
-assert x == y == 42, 'cached CONST_INT should be consistent'
-
-# === Mixed: constants and external functions in the same code ===
-result = add_ints(CONST_INT, 8)
-assert result == 50, f'add_ints(CONST_INT, 8) should be 50, got {result}'
-
-str_result = concat_strings(CONST_STR, ' world')
-assert str_result == 'hello world', f'concat with CONST_STR should be hello world, got {str_result}'
-
-# === Constants used in control flow ===
-if CONST_BOOL:
-    flag = 'yes'
-else:
-    flag = 'no'
-assert flag == 'yes', f'CONST_BOOL in if should take true branch, got {flag}'
-
-# === Constants used in loops ===
-total = 0
-for item in CONST_LIST:
-    total = total + item
-assert total == 6, f'sum of CONST_LIST should be 6, got {total}'
-
-
-# === Constants in function scope ===
-def use_constant():
-    return CONST_INT * 2
-
-
-assert use_constant() == 84, f'CONST_INT in function should be 84, got {use_constant()}'

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

@@ -1,4 +0,0 @@
-# call-external
-# When NameLookup returns Undefined for an unknown name, NameError is raised.
-totally_unknown_name
-# Raise=NameError("name 'totally_unknown_name' is not defined")

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

@@ -1,14 +0,0 @@
-# call-external
-# External calls in nested call expressions
-
-# Nested external calls - inner first
-result = add_ints(add_ints(1, 2), 3)
-assert result == 6, 'nested ext calls'
-
-# Triple nested
-result = add_ints(add_ints(add_ints(1, 1), 2), 3)
-assert result == 7, 'triple nested ext calls'
-
-# Two separate nested calls
-result = add_ints(add_ints(1, 2), add_ints(3, 4))
-assert result == 10, 'two nested ext calls in args'

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

@@ -1,19 +0,0 @@
-# call-external
-# BUG: External calls in recursive functions produce wrong results
-# Recursion with external calls doesn't compute the correct value
-
-
-def sum_with_ext(n):
-    if n <= 0:
-        return 0
-    return add_ints(n, sum_with_ext(n - 1))
-
-
-# sum_with_ext(3) should compute:
-#   add_ints(3, sum_with_ext(2))
-#   add_ints(3, add_ints(2, sum_with_ext(1)))
-#   add_ints(3, add_ints(2, add_ints(1, sum_with_ext(0))))
-#   add_ints(3, add_ints(2, add_ints(1, 0)))
-#   = 3 + 2 + 1 = 6
-result = sum_with_ext(3)
-assert result == 6, 'recursive ext call: 1+2+3=6'

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

@@ -1,28 +0,0 @@
-# call-external
-# External calls in return statements
-
-
-def direct_return():
-    return add_ints(10, 20)
-
-
-result = direct_return()
-assert result == 30, 'ext call as direct return value'
-
-
-def return_with_expression():
-    return add_ints(1, 2) + add_ints(3, 4)
-
-
-result = return_with_expression()
-assert result == 10, 'ext call expression as return value'
-
-
-def conditional_return():
-    if return_value(True):
-        return add_ints(100, 200)
-    return add_ints(1, 1)
-
-
-result = conditional_return()
-assert result == 300, 'ext call in conditional return'

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

@@ -1,25 +0,0 @@
-# call-external
-def log(msg):
-    print(msg)
-    return 1
-
-
-def inner(x):
-    print('Inner called')
-    val = add_ints(x, 1)  # External call
-    print('Inner resumed')
-    return val
-
-
-def outer():
-    print('Outer calling inner')
-    # If side effects are duplicated, we'll see "Evaluating arg" twice
-    res = inner(log('Evaluating arg'))
-    print('Outer returned')
-    return res
-
-
-print('Starting')
-res = outer()
-print(f'Result: {res}')
-assert res == 2

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

@@ -1,7 +0,0 @@
-# call-external
-# External calls in subscript operations
-
-# External call as subscript index
-items = [10, 20, 30]
-result = items[add_ints(0, 1)]
-assert result == 20, 'ext call as subscript index'

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

@@ -1,28 +0,0 @@
-# call-external
-# External calls in ternary expressions (if/else expressions)
-
-# External call in true branch
-result = add_ints(1, 2) if True else add_ints(10, 20)
-assert result == 3, 'ext call in ternary true branch'
-
-# External call in false branch
-result = add_ints(1, 2) if False else add_ints(10, 20)
-assert result == 30, 'ext call in ternary false branch'
-
-# External call in condition
-result = 'yes' if return_value(True) else 'no'
-assert result == 'yes', 'ext call in ternary condition (true)'
-
-result = 'yes' if return_value(False) else 'no'
-assert result == 'no', 'ext call in ternary condition (false)'
-
-# External calls in both branches
-result = add_ints(1, 2) if return_value(True) else add_ints(10, 20)
-assert result == 3, 'ext call in condition and true branch'
-
-result = add_ints(1, 2) if return_value(False) else add_ints(10, 20)
-assert result == 30, 'ext call in condition and false branch'
-
-# Nested ternary with external calls
-result = add_ints(1, 1) if return_value(True) else (add_ints(2, 2) if return_value(False) else add_ints(3, 3))
-assert result == 2, 'nested ternary with ext calls'

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

@@ -1,280 +0,0 @@
-# call-external
-# === External calls in try blocks ===
-
-# Basic external call in try body
-result = None
-try:
-    result = add_ints(10, 20)
-except:
-    result = -1
-assert result == 30, 'ext call in try body'
-
-# Multiple external calls in try body
-try:
-    a = add_ints(1, 2)
-    b = add_ints(3, 4)
-    c = add_ints(a, b)
-except:
-    c = -1
-assert c == 10, 'multiple ext calls in try body'
-
-# Nested external calls in try body
-try:
-    nested = add_ints(add_ints(1, 2), add_ints(3, 4))
-except:
-    nested = -1
-assert nested == 10, 'nested ext calls in try body'
-
-# === External calls in except blocks ===
-
-# External call in except handler
-handler_result = None
-try:
-    raise ValueError('error')
-except ValueError:
-    handler_result = add_ints(100, 200)
-assert handler_result == 300, 'ext call in except handler'
-
-# Multiple external calls in except handler
-try:
-    raise TypeError('error')
-except TypeError:
-    x = add_ints(5, 5)
-    y = add_ints(10, 10)
-    handler_sum = add_ints(x, y)
-assert handler_sum == 30, 'multiple ext calls in except handler'
-
-# External call with exception variable
-exc_with_ext = None
-try:
-    raise ValueError('test')
-except ValueError as e:
-    prefix = concat_strings('caught: ', repr(e))
-    exc_with_ext = prefix
-assert exc_with_ext == "caught: ValueError('test')", 'ext call with exception variable'
-
-# === External calls in else blocks ===
-
-# External call in else block
-else_result = None
-try:
-    x = 1  # No exception
-except:
-    else_result = -1
-else:
-    else_result = add_ints(50, 50)
-assert else_result == 100, 'ext call in else block'
-
-# Multiple external calls in else block
-try:
-    pass
-except:
-    else_multi = -1
-else:
-    p = add_ints(1, 2)
-    q = add_ints(3, 4)
-    else_multi = add_ints(p, q)
-assert else_multi == 10, 'multiple ext calls in else block'
-
-# === External calls in finally blocks ===
-
-# External call in finally block
-finally_result = None
-try:
-    x = 1
-finally:
-    finally_result = add_ints(25, 75)
-assert finally_result == 100, 'ext call in finally block'
-
-# Finally with external call after exception caught
-finally_after_exc = None
-try:
-    raise ValueError('error')
-except ValueError:
-    pass
-finally:
-    finally_after_exc = add_ints(1, 99)
-assert finally_after_exc == 100, 'ext call in finally after caught exception'
-
-# Multiple external calls in finally
-try:
-    pass
-finally:
-    f1 = add_ints(10, 20)
-    f2 = add_ints(30, 40)
-    finally_multi = add_ints(f1, f2)
-assert finally_multi == 100, 'multiple ext calls in finally block'
-
-# === External calls across multiple phases ===
-
-# External calls in try, except, and finally
-all_phases = []
-try:
-    all_phases.append(add_ints(1, 0))  # 1
-    raise ValueError('error')
-except ValueError:
-    all_phases.append(add_ints(2, 0))  # 2
-finally:
-    all_phases.append(add_ints(3, 0))  # 3
-assert all_phases == [1, 2, 3], 'ext calls in try, except, and finally'
-
-# External calls in try, else, and finally (no exception)
-no_exc_phases = []
-try:
-    no_exc_phases.append(add_ints(10, 0))  # 10
-except:
-    no_exc_phases.append(-1)
-else:
-    no_exc_phases.append(add_ints(20, 0))  # 20
-finally:
-    no_exc_phases.append(add_ints(30, 0))  # 30
-assert no_exc_phases == [10, 20, 30], 'ext calls in try, else, and finally'
-
-# === External calls in nested try blocks ===
-
-# Nested try with external calls at each level
-outer_val = None
-inner_val = None
-try:
-    outer_val = add_ints(100, 0)
-    try:
-        inner_val = add_ints(200, 0)
-        raise ValueError('inner')
-    except ValueError:
-        inner_val = add_ints(inner_val, 50)
-except:
-    outer_val = -1
-assert outer_val == 100, 'ext call in outer try'
-assert inner_val == 250, 'ext call in inner try and handler'
-
-# === External calls in exception type expression ===
-# (Exception type is evaluated at handler matching time)
-
-# External call producing value used after try
-post_try = None
-try:
-    pre = add_ints(5, 5)
-except:
-    pre = -1
-post_try = add_ints(pre, 10)
-assert post_try == 20, 'ext call result used after try block'
-
-# === External call in finally with unhandled exception ===
-# Finally should still run even when exception propagates
-finally_with_propagate = None
-try:
-    try:
-        finally_with_propagate = add_ints(0, 0)  # Initialize
-        raise KeyError('unhandled')
-    except ValueError:
-        pass  # Won't catch KeyError
-    finally:
-        finally_with_propagate = add_ints(42, 0)  # Should still run
-except KeyError:
-    pass  # Catch propagated exception
-assert finally_with_propagate == 42, 'ext call in finally should run even with unhandled exception'
-
-# === External call in except handler that then raises ===
-handler_before_raise = None
-try:
-    try:
-        raise ValueError('original')
-    except ValueError:
-        handler_before_raise = add_ints(10, 0)  # External call before raising
-        raise TypeError('from handler')
-except TypeError:
-    pass
-assert handler_before_raise == 10, 'ext call in handler before raising'
-
-# === External call in else block that then raises ===
-else_before_raise = None
-try:
-    try:
-        pass  # No exception
-    except:
-        pass
-    else:
-        else_before_raise = add_ints(20, 0)  # External call before raising
-        raise ValueError('from else')
-except ValueError:
-    pass
-assert else_before_raise == 20, 'ext call in else before raising'
-
-# === External call preserves state across try/except ===
-state_before = add_ints(1000, 0)
-state_after = None
-try:
-    state_after = add_ints(state_before, 1)
-    raise ValueError('test')
-except ValueError:
-    state_after = add_ints(state_after, 10)
-finally:
-    state_after = add_ints(state_after, 100)
-assert state_after == 1111, 'state preserved across try/except with ext calls'
-
-# === Multiple except handlers with external calls ===
-which_handler = None
-try:
-    raise TypeError('test')
-except ValueError:
-    which_handler = add_ints(1, 0)
-except TypeError:
-    which_handler = add_ints(2, 0)
-except KeyError:
-    which_handler = add_ints(3, 0)
-assert which_handler == 2, 'ext call in correct handler with multiple handlers'
-
-# === External call in finally with pending exception (after handler raises) ===
-finally_after_handler_raise = None
-try:
-    try:
-        raise ValueError('original')
-    except ValueError:
-        finally_after_handler_raise = add_ints(10, 0)  # External call before raising
-        raise TypeError('from handler')
-    finally:
-        # This external call should work even though there's a pending exception
-        finally_after_handler_raise = add_ints(finally_after_handler_raise, 5)
-except TypeError:
-    pass
-assert finally_after_handler_raise == 15, 'ext call in finally with pending exception from handler'
-
-# === External call in finally with pending exception (no matching handler) ===
-finally_with_pending_exc = None
-try:
-    try:
-        finally_with_pending_exc = add_ints(0, 0)
-        raise KeyError('no handler')
-    except ValueError:
-        pass  # Won't catch KeyError
-    finally:
-        # This external call should work even though KeyError is pending
-        finally_with_pending_exc = add_ints(100, 0)
-except KeyError:
-    pass  # Catch it here
-assert finally_with_pending_exc == 100, 'ext call in finally with unhandled exception pending'
-
-# === External call in finally with return (uses simple values) ===
-# Note: External calls in user-defined functions are not supported,
-# so we test pending return with built-in operations only
-finally_return_result = None
-try:
-    finally_return_result = 'in_try'
-finally:
-    pass  # finally runs but doesn't override
-assert finally_return_result == 'in_try', 'finally runs with pending value'
-
-# === Multiple external calls in finally with pending exception ===
-multi_finally = None
-try:
-    try:
-        raise ValueError('test')
-    except TypeError:
-        pass  # Won't match
-    finally:
-        a = add_ints(1, 2)
-        b = add_ints(3, 4)
-        multi_finally = add_ints(a, b)
-except ValueError:
-    pass
-assert multi_finally == 10, 'multiple ext calls in finally with pending exception'

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

@@ -1,10 +0,0 @@
-# call-external
-# Test external call with exception variable
-
-exc_with_ext = None
-try:
-    raise ValueError('test')
-except ValueError as e:
-    prefix = concat_strings('caught: ', repr(e))
-    exc_with_ext = prefix
-assert exc_with_ext == "caught: ValueError('test')", 'ext call with exception variable'

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

@@ -1,13 +0,0 @@
-# call-external
-# External calls in unary expressions
-
-# Negation of external call result
-result = -add_ints(3, 4)
-assert result == -7, 'negation of ext call'
-
-# Not of external call
-result = not return_value(False)
-assert result == True, 'not of ext call returning False'
-
-result = not return_value(True)
-assert result == False, 'not of ext call returning True'