superacli 1.1.4 → 1.1.6

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

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

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

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

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

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

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

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

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

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