superacli 1.1.5 → 1.1.7

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

@@ -1,171 +0,0 @@
-# call-external
-# === External calls in elif conditions ===
-
-# External call in elif condition - true
-result1 = 0
-if add_ints(1, 1) == 3:
-    result1 = 1
-elif add_ints(2, 2) == 4:
-    result1 = 2
-else:
-    result1 = 3
-assert result1 == 2, f'elif condition with ext call should be evaluated, {result1=}'
-
-# External call in elif condition - falls through to else
-result2 = 0
-if add_ints(1, 1) == 3:
-    result2 = 1
-elif add_ints(2, 2) == 5:
-    result2 = 2
-else:
-    result2 = 3
-assert result2 == 3, 'else taken when all ext call conditions are false'
-
-# Multiple elif with external calls
-result3 = 0
-if add_ints(1, 1) == 10:
-    result3 = 1
-elif add_ints(2, 2) == 10:
-    result3 = 2
-elif add_ints(3, 3) == 6:
-    result3 = 3
-elif add_ints(4, 4) == 10:
-    result3 = 4
-else:
-    result3 = 5
-assert result3 == 3, 'third elif with ext call should match'
-
-# === External calls in elif bodies ===
-
-# Ext call in elif body
-val1 = 0
-if False:
-    val1 = 1
-elif True:
-    val1 = add_ints(10, 20)
-else:
-    val1 = 3
-assert val1 == 30, 'ext call in elif body'
-
-# Ext call in else body after elif chain
-val2 = 0
-if False:
-    val2 = 1
-elif False:
-    val2 = 2
-else:
-    val2 = add_ints(15, 25)
-assert val2 == 40, 'ext call in else body after elif'
-
-# Multiple ext calls in elif body
-val3 = 0
-if False:
-    val3 = 1
-elif True:
-    a = add_ints(5, 5)
-    b = add_ints(10, 10)
-    val3 = add_ints(a, b)
-else:
-    val3 = 3
-assert val3 == 30, 'multiple ext calls in elif body'
-
-# === Nested ext calls ===
-
-# Nested ext calls in elif condition
-result4 = 0
-if False:
-    result4 = 1
-elif add_ints(add_ints(1, 2), add_ints(3, 4)) == 10:
-    result4 = 2
-else:
-    result4 = 3
-assert result4 == 2, 'nested ext calls in elif condition'
-
-# === Short-circuit with ext calls ===
-
-# Ext call should not be evaluated if earlier condition is true
-call_count = 0
-
-
-def counting_add(a, b):
-    global call_count
-    call_count = call_count + 1
-    return a + b
-
-
-# This uses a regular function, not ext call, to verify short-circuit
-# but the ext calls in bodies still test suspension
-x = 0
-if True:
-    x = add_ints(1, 1)
-elif False:
-    x = add_ints(2, 2)
-assert x == 2, 'if body ext call executed, elif skipped'
-
-# === Ext call in both condition and body ===
-
-result5 = 0
-if add_ints(1, 1) == 3:
-    result5 = add_ints(100, 100)
-elif add_ints(2, 2) == 4:
-    result5 = add_ints(50, 50)
-else:
-    result5 = add_ints(25, 25)
-assert result5 == 100, 'ext call in both elif condition and body'
-
-# === Ext call in if body when condition is true ===
-
-if_body_result = 0
-if add_ints(5, 5) == 10:
-    if_body_result = add_ints(100, 200)
-elif add_ints(1, 1) == 2:
-    if_body_result = add_ints(10, 20)
-else:
-    if_body_result = add_ints(1, 2)
-assert if_body_result == 300, 'ext call in if body when if condition is true'
-
-# === Ext calls returning values used as conditions ===
-
-# return_value returns its argument, so we can use it to test boolean coercion
-cond_result = 0
-if return_value(0):
-    cond_result = 1
-elif return_value(1):
-    cond_result = 2
-else:
-    cond_result = 3
-assert cond_result == 2, 'ext call return value used as boolean condition'
-
-# === Ext calls with string concatenation ===
-
-str_result = ''
-if add_ints(1, 1) == 3:
-    str_result = concat_strings('a', 'b')
-elif add_ints(2, 2) == 4:
-    str_result = concat_strings('hello', ' world')
-else:
-    str_result = concat_strings('x', 'y')
-assert str_result == 'hello world', 'ext call with string result in elif body'
-
-# === Multiple conditions with ext calls in same expression ===
-
-multi_cond = 0
-if add_ints(1, 1) > 5:
-    multi_cond = 1
-elif add_ints(2, 2) < add_ints(3, 3):
-    multi_cond = 2
-else:
-    multi_cond = 3
-assert multi_cond == 2, 'comparison between two ext call results in elif condition'
-
-# === Ext call in all three branches ===
-
-all_branches = 0
-val = add_ints(5, 5)
-if val < 5:
-    all_branches = add_ints(1, 0)
-elif val < 15:
-    all_branches = add_ints(2, 0)
-else:
-    all_branches = add_ints(3, 0)
-assert all_branches == 2, 'ext call in elif body based on earlier ext call result'

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

@@ -1,4 +0,0 @@
-# call-external
-# External call in raise statement
-raise ValueError(return_value('foobar'))
-# Raise=ValueError('foobar')

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

@@ -1,39 +0,0 @@
-# call-external
-def level4():
-    x = 1
-    raise_error('RuntimeError', 'deep error')
-
-
-def level3():
-    level4()
-
-
-def level2():
-    level3()
-
-
-def level1():
-    level2()
-
-
-level1()
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "ext_call__exc_deep_stack.py", line 19, in <module>
-    level1()
-    ~~~~~~~~
-  File "ext_call__exc_deep_stack.py", line 16, in level1
-    level2()
-    ~~~~~~~~
-  File "ext_call__exc_deep_stack.py", line 12, in level2
-    level3()
-    ~~~~~~~~
-  File "ext_call__exc_deep_stack.py", line 8, in level3
-    level4()
-    ~~~~~~~~
-  File "ext_call__exc_deep_stack.py", line 4, in level4
-    raise_error('RuntimeError', 'deep error')
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-RuntimeError: deep error
-"""

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

@@ -1,17 +0,0 @@
-# call-external
-def wrapper():
-    raise_error('ValueError', 'from external')
-
-
-wrapper()
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "ext_call__exc_in_function.py", line 6, in <module>
-    wrapper()
-    ~~~~~~~~~
-  File "ext_call__exc_in_function.py", line 3, in wrapper
-    raise_error('ValueError', 'from external')
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-ValueError: from external
-"""

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

@@ -1,31 +0,0 @@
-# call-external
-def inner():
-    raise_error('TypeError', 'nested error')
-
-
-def middle():
-    inner()
-
-
-def outer():
-    middle()
-
-
-outer()
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "ext_call__exc_nested_functions.py", line 14, in <module>
-    outer()
-    ~~~~~~~
-  File "ext_call__exc_nested_functions.py", line 11, in outer
-    middle()
-    ~~~~~~~~
-  File "ext_call__exc_nested_functions.py", line 7, in middle
-    inner()
-    ~~~~~~~
-  File "ext_call__exc_nested_functions.py", line 3, in inner
-    raise_error('TypeError', 'nested error')
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-TypeError: nested error
-"""

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

@@ -1,171 +0,0 @@
-# call-external
-# === External function exceptions ===
-# Tests for exceptions raised by external functions
-
-# === Basic exception propagation ===
-
-# External function raising ValueError
-caught_value_error = False
-try:
-    result = raise_error('ValueError', 'test error')
-    assert False, 'should not reach here'
-except ValueError:
-    caught_value_error = True
-assert caught_value_error, 'ValueError was caught'
-
-# External function raising TypeError
-caught_type_error = False
-try:
-    result = raise_error('TypeError', 'type error message')
-    assert False, 'should not reach here'
-except TypeError:
-    caught_type_error = True
-assert caught_type_error, 'TypeError was caught'
-
-# External function raising KeyError
-caught_key_error = False
-try:
-    result = raise_error('KeyError', 'missing key')
-    assert False, 'should not reach here'
-except KeyError:
-    caught_key_error = True
-assert caught_key_error, 'KeyError was caught'
-
-# External function raising RuntimeError
-caught_runtime_error = False
-try:
-    result = raise_error('RuntimeError', 'runtime error')
-    assert False, 'should not reach here'
-except RuntimeError:
-    caught_runtime_error = True
-assert caught_runtime_error, 'RuntimeError was caught'
-
-# === Exception not caught by wrong handler ===
-
-# ValueError not caught by TypeError handler
-caught_outer = False
-try:
-    try:
-        raise_error('ValueError', 'inner error')
-    except TypeError:
-        assert False, 'TypeError should not catch ValueError'
-except ValueError:
-    caught_outer = True
-assert caught_outer, 'ValueError caught by outer handler'
-
-# === Exception in expression with multiple ext calls ===
-
-# First ext call raises, second should not be called
-try:
-    x = raise_error('ValueError', 'first') + add_ints(1, 2)
-    assert False, 'should not reach here'
-except ValueError:
-    pass  # Expected
-
-# === External exception in try body with finally ===
-
-finally_ran = False
-try:
-    raise_error('ValueError', 'in try')
-except ValueError:
-    pass  # Caught
-finally:
-    finally_ran = True
-assert finally_ran, 'finally ran after external exception caught'
-
-# External exception propagating through finally
-outer_caught = False
-finally_ran2 = False
-try:
-    try:
-        raise_error('KeyError', 'will propagate')
-    except ValueError:
-        assert False, 'ValueError should not catch KeyError'
-    finally:
-        finally_ran2 = True
-except KeyError:
-    outer_caught = True
-assert finally_ran2, 'finally ran before exception propagated'
-assert outer_caught, 'exception propagated after finally'
-
-# === Mix of normal returns and exceptions ===
-
-# Normal return, then exception
-value1 = add_ints(10, 20)
-assert value1 == 30, 'first ext call returned normally'
-try:
-    raise_error('ValueError', 'after success')
-    assert False, 'should not reach here'
-except ValueError:
-    pass  # Expected
-
-# Exception, then normal return (after catching)
-caught_exc = False
-try:
-    raise_error('TypeError', 'will be caught')
-except TypeError:
-    caught_exc = True
-value2 = add_ints(5, 5)
-assert caught_exc, 'exception was caught'
-assert value2 == 10, 'ext call after caught exception returned normally'
-
-# === Exception in except handler from external function ===
-
-outer_catch = False
-try:
-    try:
-        raise ValueError('inner')
-    except ValueError:
-        raise_error('TypeError', 'from handler')
-except TypeError:
-    outer_catch = True
-assert outer_catch, 'exception from handler caught by outer'
-
-# === Exception in else block from external function ===
-
-else_exc_caught = False
-try:
-    try:
-        pass  # No exception
-    except:
-        assert False, 'should not reach except'
-    else:
-        raise_error('RuntimeError', 'from else')
-except RuntimeError:
-    else_exc_caught = True
-assert else_exc_caught, 'exception from else block caught'
-
-# === Exception in finally block ===
-
-# Note: exception in finally replaces any pending exception
-finally_exc_caught = False
-try:
-    try:
-        pass
-    finally:
-        raise_error('ValueError', 'from finally')
-except ValueError:
-    finally_exc_caught = True
-assert finally_exc_caught, 'exception from finally caught'
-
-# === Nested try blocks with external exceptions ===
-
-inner_handled = False
-outer_handled = False
-finally_count = 0
-try:
-    try:
-        raise_error('ValueError', 'inner error')
-    except ValueError:
-        inner_handled = True
-        raise_error('TypeError', 'from inner handler')
-    finally:
-        finally_count += 1
-except TypeError:
-    outer_handled = True
-finally:
-    finally_count += 1
-
-assert inner_handled, 'inner exception was handled'
-assert outer_handled, 'exception from inner handler was caught by outer'
-assert finally_count == 2, 'both finally blocks ran'

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

@@ -1,114 +0,0 @@
-# call-external
-# === External calls in for loops ===
-
-# Ext call in loop body
-total = 0
-for i in range(3):
-    total = add_ints(total, 1)
-assert total == 3, f'ext call accumulator in loop, {total=}'
-
-# Ext call with loop variable
-sum_val = 0
-for i in range(4):
-    sum_val = add_ints(sum_val, i)
-assert sum_val == 6, 'ext call with loop var'
-
-# Multiple ext calls per iteration
-result = 0
-for i in range(3):
-    result = add_ints(result, add_ints(i, i))
-assert result == 6, 'nested ext calls in loop'
-
-# Building list with ext calls
-items = []
-for i in range(3):
-    items.append(add_ints(i, 10))
-assert items[0] == 10, 'ext call list build first'
-assert items[1] == 11, 'ext call list build second'
-assert items[2] == 12, 'ext call list build third'
-
-# Chained ext calls in loop
-acc = 0
-for i in range(3):
-    acc = add_ints(acc, 1) + add_ints(0, 1)
-assert acc == 6, 'chained ext calls in loop body'
-
-# Nested loops with ext calls
-matrix_sum = 0
-for i in range(2):
-    for j in range(2):
-        matrix_sum = add_ints(matrix_sum, add_ints(i, j))
-assert matrix_sum == 4, 'ext calls in nested loops'
-
-# === More nested loop edge cases ===
-
-# Nested loops building a result list
-results = []
-for i in range(2):
-    for j in range(2):
-        results.append(concat_strings(return_value(str(i)), return_value(str(j))))
-assert results[0] == '00', 'nested loops result list first'
-assert results[1] == '01', 'nested loops result list second'
-assert results[2] == '10', 'nested loops result list third'
-assert results[3] == '11', 'nested loops result list fourth'
-
-# If inside for loop with external call condition
-filtered = []
-for i in range(3):
-    if return_value(i) == i:
-        filtered.append(i)
-assert filtered == [0, 1, 2], 'if inside for with ext condition'
-
-# If inside for loop - some iterations match
-results2 = []
-for i in range(4):
-    # Only append even numbers (using modulo check with add_ints)
-    if add_ints(i, 0) % 2 == 0:
-        results2.append(return_value(i))
-assert results2 == [0, 2], 'if inside for filtering with ext'
-
-# Nested for with different ranges
-outer_sum = 0
-for i in range(2):
-    inner_sum = 0
-    for j in range(3):
-        inner_sum = add_ints(inner_sum, add_ints(i, j))
-    outer_sum = add_ints(outer_sum, inner_sum)
-# i=0: (0+0)+(0+1)+(0+2) = 0+1+2 = 3
-# i=1: (1+0)+(1+1)+(1+2) = 1+2+3 = 6
-# total = 3 + 6 = 9
-assert outer_sum == 9, 'nested for with accumulator'
-
-# Three levels of nested loops
-count = 0
-for i in range(2):
-    for j in range(2):
-        for k in range(2):
-            count = add_ints(count, 1)
-assert count == 8, 'triple nested for with ext call'
-
-# multiple ext calls in iterable
-
-ext_ints = []
-for i in add_ints(1, 1), add_ints(2, 2), add_ints(3, 3):
-    ext_ints.append(i)
-assert ext_ints == [2, 4, 6], 'multiple ext calls in iterable'
-
-# ext call iterable, get_list() returns [1, 2, 3]
-total = 0
-for x in get_list():
-    total = add_ints(total, x)
-assert total == 6, 'ext call iterable'
-
-# string iteration with ext call in body
-chars = []
-for c in 'abc':
-    chars.append(return_value(c))
-assert chars == ['a', 'b', 'c'], f'string iteration with ext call: {chars}'
-
-# unicode string iteration with ext call in body
-# Tests decr() handling of multi-byte UTF-8 characters (1-4 bytes each)
-unicode_chars = []
-for c in 'aé中😀b':  # a (1 byte), e-acute (2), chinese (3), emoji (4), b (1)
-    unicode_chars.append(return_value(c))
-assert unicode_chars == ['a', 'é', '中', '😀', 'b'], f'unicode iteration: {unicode_chars}'

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

@@ -1,12 +0,0 @@
-# call-external
-# External calls in f-strings
-
-s = f'result is {add_ints(10, 20)}'
-assert s == 'result is 30', 'ext call in f-string'
-
-s = f'a={add_ints(1, 2)}, b={add_ints(3, 4)}'
-assert s == 'a=3, b=7', 'multiple ext calls in f-string'
-
-# Nested external call in f-string
-s = f'nested={add_ints(add_ints(1, 2), 3)}'
-assert s == 'nested=6', 'nested ext call in f-string'

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

@@ -1,135 +0,0 @@
-# call-external
-# === External calls in if/else expressions ===
-
-# Ternary expression with ext call in condition
-result = 'yes' if add_ints(1, 1) == 2 else 'no'
-assert result == 'yes', 'ext call in ternary condition true'
-
-result2 = 'yes' if add_ints(1, 1) == 3 else 'no'
-assert result2 == 'no', 'ext call in ternary condition false'
-
-# Ext call in true branch
-val = add_ints(10, 20) if True else 0
-assert val == 30, 'ext call in ternary true branch'
-
-# Ext call in false branch
-val2 = 0 if False else add_ints(5, 5)
-assert val2 == 10, 'ext call in ternary false branch'
-
-# Ext calls in both branches
-val3 = add_ints(1, 2) if True else add_ints(3, 4)
-assert val3 == 3, 'ext call in both branches takes true'
-
-val4 = add_ints(1, 2) if False else add_ints(3, 4)
-assert val4 == 7, 'ext call in both branches takes false'
-
-# === If statements with external calls ===
-
-# Ext call in if condition
-x = 0
-if add_ints(1, 1) == 2:
-    x = 100
-assert x == 100, 'ext call in if statement condition true'
-
-y = 0
-if add_ints(1, 1) == 3:
-    y = 100
-assert y == 0, 'ext call in if statement condition false'
-
-# Ext call in if body
-z = 0
-if True:
-    z = add_ints(50, 50)
-assert z == 100, 'ext call in if body'
-
-# Ext call in else body
-w = 0
-if False:
-    w = 1
-else:
-    w = add_ints(25, 75)
-assert w == 100, 'ext call in else body'
-
-# Nested ext calls in condition
-nested = 0
-if add_ints(add_ints(1, 2), add_ints(3, 4)) == 10:
-    nested = 1
-assert nested == 1, 'nested ext calls in if condition'
-
-# Chained conditions with ext calls
-result3 = 0
-if add_ints(1, 1) == 2 and add_ints(2, 2) == 4:
-    result3 = 1
-assert result3 == 1, 'multiple ext calls in and condition'
-
-result4 = 0
-if add_ints(1, 1) == 3 or add_ints(2, 2) == 4:
-    result4 = 1
-assert result4 == 1, 'multiple ext calls in or condition'
-
-# Comparison with ext call results
-cmp = add_ints(10, 5) > add_ints(5, 5)
-assert cmp == True, 'comparing two ext call results'
-
-# === Nested if statements with external calls ===
-
-# Nested if with ext calls in both conditions (both true)
-result = 'none'
-if return_value(1) == 1:
-    if return_value(2) == 2:
-        result = 'inner'
-    else:
-        result = 'outer_only'
-else:
-    result = 'failed'
-assert result == 'inner', 'nested if both conditions true'
-
-# Nested if - outer true, inner false
-result2 = 'none'
-if return_value(1) == 1:
-    if return_value(2) == 999:
-        result2 = 'inner'
-    else:
-        result2 = 'outer_only'
-else:
-    result2 = 'failed'
-assert result2 == 'outer_only', 'nested if inner false'
-
-# Nested if - outer false
-result3 = 'none'
-if return_value(1) == 999:
-    if return_value(2) == 2:
-        result3 = 'inner'
-    else:
-        result3 = 'outer_only'
-else:
-    result3 = 'xxx'
-assert result3 == 'xxx', 'nested if outer false'
-
-# Triple nested if - all true
-result4 = 0
-if return_value(1) == 1:
-    if return_value(2) == 2:
-        if return_value(3) == 3:
-            result4 = 123
-assert result4 == 123, 'triple nested if all true'
-
-# If condition with multiple ext calls (addition)
-result5 = 0
-if add_ints(1, 2) + add_ints(3, 4) == 10:
-    result5 = 1
-assert result5 == 1, 'if condition with multiple ext calls'
-
-# For loop inside if with external condition
-total = 0
-if return_value(1) == 1:
-    for i in range(3):
-        total = add_ints(total, return_value(i))
-assert total == 3, 'for loop inside if with ext condition'
-
-# For loop inside if - condition false
-total2 = 0
-if return_value(1) == 999:
-    for i in range(3):
-        total2 = add_ints(total2, i)
-assert total2 == 0, 'for loop inside if condition false'