superacli 1.1.5 → 1.1.7

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

@@ -1,207 +0,0 @@
-# === Basic elif chains ===
-
-# if branch taken
-x = 0
-if True:
-    x = 1
-elif True:
-    x = 2
-assert x == 1, 'if branch should be taken when condition is True'
-
-# elif branch taken (first elif)
-y = 0
-if False:
-    y = 1
-elif True:
-    y = 2
-elif True:
-    y = 3
-assert y == 2, 'first elif should be taken when if is False and elif is True'
-
-# second elif taken
-z = 0
-if False:
-    z = 1
-elif False:
-    z = 2
-elif True:
-    z = 3
-assert z == 3, 'second elif should be taken'
-
-# else branch taken after if
-a = 0
-if False:
-    a = 1
-else:
-    a = 2
-assert a == 2, 'else should be taken when if is False'
-
-# else branch taken after elif chain
-b = 0
-if False:
-    b = 1
-elif False:
-    b = 2
-elif False:
-    b = 3
-else:
-    b = 4
-assert b == 4, 'else should be taken when all conditions are False'
-
-# === Value-based conditions ===
-
-val = 5
-
-c = 0
-if val < 3:
-    c = 1
-elif val < 6:
-    c = 2
-elif val < 9:
-    c = 3
-else:
-    c = 4
-assert c == 2, 'elif condition val < 6 should match for val=5'
-
-val2 = 10
-d = 0
-if val2 < 3:
-    d = 1
-elif val2 < 6:
-    d = 2
-elif val2 < 9:
-    d = 3
-else:
-    d = 4
-assert d == 4, 'else should be taken for val2=10'
-
-# === Multiple statements in branches ===
-
-e = 0
-f = 0
-if False:
-    e = 1
-    f = 1
-elif True:
-    e = 2
-    f = 2
-else:
-    e = 3
-    f = 3
-assert e == 2, 'first statement in elif executed'
-assert f == 2, 'second statement in elif executed'
-
-# === Nested if inside elif ===
-
-g = 0
-if False:
-    g = 1
-elif True:
-    if True:
-        g = 100
-    else:
-        g = 200
-else:
-    g = 3
-assert g == 100, 'nested if inside elif should work'
-
-# nested if in else
-h = 0
-if False:
-    h = 1
-elif False:
-    h = 2
-else:
-    if True:
-        h = 300
-    else:
-        h = 400
-assert h == 300, 'nested if inside else should work'
-
-# === Short-circuit evaluation ===
-
-# elif condition not evaluated if earlier branch taken
-called = False
-
-
-def set_called():
-    global called
-    called = True
-    return True
-
-
-i = 0
-if True:
-    i = 1
-elif set_called():
-    i = 2
-assert i == 1, 'if branch taken'
-assert called == False, 'elif condition should not be evaluated when if branch is taken'
-
-# reset and test elif evaluation
-called = False
-j = 0
-if False:
-    j = 1
-elif set_called():
-    j = 2
-assert j == 2, 'elif branch taken'
-assert called == True, 'elif condition should be evaluated when if condition is False'
-
-# === Empty body handling (pass) ===
-
-k = 0
-if False:
-    pass
-elif True:
-    k = 1
-else:
-    pass
-assert k == 1, 'elif body executes after if with pass'
-
-# === Boolean expression conditions ===
-
-and_result = 0
-if False and True:
-    and_result = 1
-elif True and True:
-    and_result = 2
-else:
-    and_result = 3
-assert and_result == 2, 'elif with and condition'
-
-or_result = 0
-if False or False:
-    or_result = 1
-elif False or True:
-    or_result = 2
-else:
-    or_result = 3
-assert or_result == 2, 'elif with or condition'
-
-# === Multiple conditions with and ===
-
-n = 5
-o = 0
-if n > 1 and n < 3:
-    o = 1
-elif n > 3 and n < 7:
-    o = 2
-else:
-    o = 3
-assert o == 2, 'elif with multiple and conditions'
-
-# === Variable assignment in conditions (walrus operator style via temp var) ===
-
-# Test value propagation through elif chain
-p = 0
-temp = 10
-if temp > 20:
-    p = 1
-elif temp > 5:
-    p = 2
-elif temp > 0:
-    p = 3
-else:
-    p = 4
-assert p == 2, 'second condition matches temp=10'

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

@@ -1,11 +0,0 @@
-if False:
-    pass
-elif True:
-    raise ValueError('in elif body')
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "if__raise_elif.py", line 4, in <module>
-    raise ValueError('in elif body')
-ValueError: in elif body
-"""

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

@@ -1,13 +0,0 @@
-if False:
-    pass
-elif False:
-    pass
-else:
-    raise ValueError('in else body')
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "if__raise_else.py", line 6, in <module>
-    raise ValueError('in else body')
-ValueError: in else body
-"""

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

@@ -1,9 +0,0 @@
-if True:
-    raise ValueError('in if body')
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "if__raise_if.py", line 2, in <module>
-    raise ValueError('in if body')
-ValueError: in if body
-"""

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

@@ -1,18 +0,0 @@
-def fail():
-    raise ValueError('elif condition failed')
-
-
-if False:
-    x = 1
-elif fail():
-    x = 2
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "if__raise_in_elif_condition.py", line 7, in <module>
-    elif fail():
-         ~~~~~~
-  File "if__raise_in_elif_condition.py", line 2, in fail
-    raise ValueError('elif condition failed')
-ValueError: elif condition failed
-"""

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

@@ -1,16 +0,0 @@
-def fail():
-    raise ValueError('condition failed')
-
-
-if fail():
-    x = 1
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "if__raise_in_if_condition.py", line 5, in <module>
-    if fail():
-       ~~~~~~
-  File "if__raise_in_if_condition.py", line 2, in fail
-    raise ValueError('condition failed')
-ValueError: condition failed
-"""

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

@@ -1,55 +0,0 @@
-# === Basic if/else ===
-assert (1 if True else 2) == 1, 'true condition'
-assert (1 if False else 2) == 2, 'false condition'
-
-# === Truthy/falsy values ===
-assert ('yes' if 1 else 'no') == 'yes', 'truthy int'
-assert ('yes' if 0 else 'no') == 'no', 'falsy int'
-assert ('yes' if 'a' else 'no') == 'yes', 'truthy str'
-assert ('yes' if '' else 'no') == 'no', 'falsy str'
-assert ('yes' if [1] else 'no') == 'yes', 'truthy list'
-assert ('yes' if [] else 'no') == 'no', 'falsy list'
-assert ('yes' if None else 'no') == 'no', 'None is falsy'
-
-# === Variables and comparisons ===
-x = 5
-assert (x if x > 0 else -x) == 5, 'positive x'
-x = -3
-assert (x if x > 0 else -x) == 3, 'negative x - abs'
-
-# === Nested if/else ===
-a = 1
-b = 2
-c = 3
-assert ((a if a > b else b) if True else c) == 2, 'nested - outer true'
-assert ((a if a > b else b) if False else c) == 3, 'nested - outer false'
-assert (a if True else (b if True else c)) == 1, 'nested in else - not evaluated'
-
-# === Complex expressions ===
-assert (1 + 2 if True else 3 + 4) == 3, 'arithmetic in body'
-assert (1 + 2 if False else 3 + 4) == 7, 'arithmetic in orelse'
-
-# === With heap values (strings, lists) ===
-s1 = 'hello'
-s2 = 'world'
-assert (s1 if True else s2) == 'hello', 'string true branch'
-assert (s1 if False else s2) == 'world', 'string false branch'
-
-l1 = [1, 2]
-l2 = [3, 4]
-result = l1 if True else l2
-assert result == [1, 2], 'list true branch'
-result = l1 if False else l2
-assert result == [3, 4], 'list false branch'
-
-# === In f-strings ===
-val = 10
-assert f'{val if val > 5 else 0}' == '10', 'fstring with true branch'
-val = 3
-assert f'{val if val > 5 else 0}' == '0', 'fstring with false branch'
-assert f'value: {1 if True else 2}' == 'value: 1', 'fstring with prefix'
-assert f'{"yes" if 1 else "no"}' == 'yes', 'fstring with string result'
-
-# === F-string with format spec ===
-x = 42
-assert f'{x if True else 0:05d}' == '00042', 'fstring format spec with if/else'

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

@@ -1,9 +0,0 @@
-from sys import nonexistent
-
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "import__error_cannot_import.py", line 1, in <module>
-    from sys import nonexistent
-ImportError: cannot import name 'nonexistent' from 'sys' (unknown location)
-"""

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

@@ -1,9 +0,0 @@
-import nonexistent_module
-
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "import__error_module_not_found.py", line 1, in <module>
-    import nonexistent_module
-ModuleNotFoundError: No module named 'nonexistent_module'
-"""

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

@@ -1,68 +0,0 @@
-# Tests that import inside functions binds to local scope, not global
-
-# === Import statement inside function ===
-def test_import_local():
-    import sys
-
-    return sys.platform
-
-
-# Call to verify import works inside function
-result = test_import_local()
-assert isinstance(result, str), 'sys.platform should be a string'
-
-# Verify sys is NOT in global scope after function call
-try:
-    sys
-    assert False, 'sys should not be in global scope'
-except NameError:
-    pass  # Expected: sys is local to the function
-
-
-# === From import inside function ===
-def test_from_import_local():
-    from typing import Any
-
-    return Any
-
-
-any_result = test_from_import_local()
-assert repr(any_result) == 'typing.Any', 'should return typing.Any'
-
-# Verify Any is NOT in global scope after function call
-try:
-    Any
-    assert False, 'Any should not be in global scope'
-except NameError:
-    pass  # Expected: Any is local to the function
-
-
-# === Aliased import inside function ===
-def test_aliased_import_local():
-    import sys as system
-
-    return system.platform
-
-
-alias_result = test_aliased_import_local()
-assert isinstance(alias_result, str), 'system.platform should be a string'
-
-# Verify system is NOT in global scope
-try:
-    system
-    assert False, 'system should not be in global scope'
-except NameError:
-    pass  # Expected: system is local to the function
-
-# === Global import remains accessible ===
-import sys as global_sys
-
-assert isinstance(global_sys.platform, str), 'global import should work'
-
-
-def use_global_import():
-    # This should access the global sys, not create a new local
-    return global_sys.platform
-
-
-assert use_global_import() == global_sys.platform, 'function should access global import'

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

@@ -1,25 +0,0 @@
-# call-external
-# Tests for os module import and os.getenv()
-
-import os
-
-# === os.getenv() with existing variable ===
-assert os.getenv('VIRTUAL_HOME') == '/virtual/home', 'getenv returns existing value'
-assert os.getenv('VIRTUAL_USER') == 'testuser', 'getenv returns user value'
-assert os.getenv('VIRTUAL_EMPTY') == '', 'getenv returns empty string value'
-
-# === os.getenv() with missing variable ===
-assert os.getenv('NONEXISTENT') is None, 'getenv returns None for missing var'
-assert os.getenv('ALSO_MISSING') is None, 'getenv returns None for other missing var'
-
-# === os.getenv() with default value ===
-assert os.getenv('NONEXISTENT', 'fallback') == 'fallback', 'getenv uses default when missing'
-assert os.getenv('ALSO_MISSING', '') == '', 'getenv uses empty string default'
-assert os.getenv('MISSING', None) is None, 'getenv with explicit None default'
-
-# === os.getenv() existing var ignores default ===
-assert os.getenv('VIRTUAL_HOME', 'ignored') == '/virtual/home', 'existing var ignores default'
-assert os.getenv('VIRTUAL_USER', 'other') == 'testuser', 'existing user ignores default'
-
-# === os.getenv() with empty string existing var ===
-assert os.getenv('VIRTUAL_EMPTY', 'not_used') == '', 'empty string var ignores default'

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

@@ -1,9 +0,0 @@
-from .foo import bar
-
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "import__relative_error.py", line 1, in <module>
-    from .foo import bar
-ImportError: attempted relative import with no known parent package
-"""

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

@@ -1,9 +0,0 @@
-from . import foo
-
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "import__relative_no_module_error.py", line 1, in <module>
-    from . import foo
-ImportError: attempted relative import with no known parent package
-"""

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

@@ -1,14 +0,0 @@
-# Verify that ModuleNotFoundError is raised when an unknown module import is actually executed
-# (not guarded by TYPE_CHECKING)
-
-condition = True
-if condition:
-    import nonexistent_at_runtime
-
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "import__runtime_error_when_executed.py", line 6, in <module>
-    import nonexistent_at_runtime
-ModuleNotFoundError: No module named 'nonexistent_at_runtime'
-"""

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

@@ -1,11 +0,0 @@
-# xfail=cpython
-from sys import *
-
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "import__star_error.py", line 2, in <module>
-    from sys import *
-    ~~~~~~~~~~~~~~~~~
-NotImplementedError: Wildcard imports (`from ... import *`) are not supported
-"""

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

@@ -1,47 +0,0 @@
-# Tests for sys module import
-
-import sys
-
-# === sys.version ===
-# Check that version is a non-empty string (exact value differs between interpreters)
-assert isinstance(sys.version, str), 'version should be a string'
-assert len(sys.version) > 0, 'version should be non-empty'
-
-# === sys.version_info ===
-# Test index access returns integers for first 3 elements
-assert isinstance(sys.version_info[0], int), 'major version should be int'
-assert isinstance(sys.version_info[1], int), 'minor version should be int'
-assert isinstance(sys.version_info[2], int), 'micro version should be int'
-assert isinstance(sys.version_info[3], str), 'releaselevel should be str'
-assert isinstance(sys.version_info[4], int), 'serial should be int'
-
-# Test negative indexing
-assert sys.version_info[-1] == sys.version_info[4], 'negative index -1 should equal index 4'
-assert sys.version_info[-2] == sys.version_info[3], 'negative index -2 should equal index 3'
-assert sys.version_info[-5] == sys.version_info[0], 'negative index -5 should equal index 0'
-
-# Test named attribute access matches index access
-assert sys.version_info.major == sys.version_info[0], 'major attr should equal index 0'
-assert sys.version_info.minor == sys.version_info[1], 'minor attr should equal index 1'
-assert sys.version_info.micro == sys.version_info[2], 'micro attr should equal index 2'
-assert sys.version_info.releaselevel == sys.version_info[3], 'releaselevel attr should equal index 3'
-assert sys.version_info.serial == sys.version_info[4], 'serial attr should equal index 4'
-
-# Test len
-assert len(sys.version_info) == 5, 'version_info should have 5 elements'
-
-# Test tuple equality (works after fixing NamedTuple equality)
-v = sys.version_info
-assert (v[0], v[1]) == (v.major, v.minor), 'tuple of indices should equal tuple of attrs'
-assert v.major == v[0], 'major attr should equal index 0'
-assert v.minor == v[1], 'minor attr should equal index 1'
-
-# === sys.platform ===
-# Check that platform is a non-empty string (exact value differs between interpreters)
-assert isinstance(sys.platform, str), 'platform should be a string'
-assert len(sys.platform) > 0, 'platform should be non-empty'
-
-# === sys.stdout and sys.stderr ===
-# These should exist - we test by accessing them (will fail if not present)
-stdout = sys.stdout
-stderr = sys.stderr

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

@@ -1,28 +0,0 @@
-# xfail=cpython
-# Tests for Monty-specific sys module values
-
-import sys
-
-# === sys.version ===
-assert sys.version == '3.14.0 (Monty)', f'version should be 3.14.0 (Monty), got {sys.version!r}'
-
-# === sys.version_info exact values ===
-assert sys.version_info[0] == 3, 'major version should be 3'
-assert sys.version_info[1] == 14, 'minor version should be 14'
-assert sys.version_info[2] == 0, 'micro version should be 0'
-assert sys.version_info[3] == 'final', 'releaselevel should be final'
-assert sys.version_info[4] == 0, 'serial should be 0'
-
-# === sys.version_info named attributes ===
-assert sys.version_info.major == 3, 'major attr should be 3'
-assert sys.version_info.minor == 14, 'minor attr should be 14'
-assert sys.version_info.micro == 0, 'micro attr should be 0'
-assert sys.version_info.releaselevel == 'final', 'releaselevel attr should be final'
-assert sys.version_info.serial == 0, 'serial attr should be 0'
-
-# === sys.version_info tuple equality ===
-# This works because NamedTuple equality compares only by elements, not type_name
-assert sys.version_info == (3, 14, 0, 'final', 0), 'version_info should equal tuple'
-
-# === sys.platform ===
-assert sys.platform == 'monty', f'platform should be monty, got {sys.platform!r}'

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

@@ -1,37 +0,0 @@
-# === TYPE_CHECKING guard ===
-# Imports inside TYPE_CHECKING blocks should not raise errors at runtime
-# because TYPE_CHECKING is False at runtime, so the import is never executed.
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    import also_nonexistent
-    from nonexistent_module import something
-
-# Verify TYPE_CHECKING is False at runtime (as expected)
-assert TYPE_CHECKING is False, 'TYPE_CHECKING should be False at runtime'
-
-
-# === Function using TYPE_CHECKING for conditional import ===
-def get_type_checking_value():
-    if TYPE_CHECKING:
-        from another_fake_module import FakeType
-    return 'success'
-
-
-result = get_type_checking_value()
-assert result == 'success', 'function with TYPE_CHECKING guard should execute'
-
-# === Nested TYPE_CHECKING blocks ===
-if TYPE_CHECKING:
-    if True:
-        from deeply_nested_fake import DeepFake
-
-# === TYPE_CHECKING in else branch (should not be executed either) ===
-x = True
-if x:
-    pass
-else:
-    if TYPE_CHECKING:
-        from unreachable_module import Unreachable
-
-assert True, 'all TYPE_CHECKING guards work correctly'

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

@@ -1,25 +0,0 @@
-# === Typing markers via from import ===
-from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
-
-# These are now assigned to Marker values (not silently ignored)
-# Test repr() to verify they have the correct string representation
-assert repr(Any) == 'typing.Any', f'Any repr should be Any, got {Any!r}'
-assert repr(Optional) == 'typing.Optional', f'Optional repr should be Optional, got {Optional!r}'
-assert repr(Union) == "<class 'typing.Union'>", f'Union repr should be <class typing.Union>, got {Union!r}'
-assert repr(List) == 'typing.List', f'List repr should be List, got {List!r}'
-assert repr(Dict) == 'typing.Dict', f'Dict repr should be Dict, got {Dict!r}'
-assert repr(Tuple) == 'typing.Tuple', f'Tuple repr should be Tuple, got {Tuple!r}'
-assert repr(Set) == 'typing.Set', f'Set repr should be Set, got {Set!r}'
-assert repr(Callable) == 'typing.Callable', f'Callable repr should be Callable, got {Callable!r}'
-
-# === Typing markers via module import ===
-import typing
-
-assert repr(typing.Any) == 'typing.Any'
-assert repr(typing.Optional) == 'typing.Optional'
-assert repr(typing.Union) == "<class 'typing.Union'>"
-
-# === Aliased imports ===
-from typing import Any as AnyType
-
-assert repr(AnyType) == 'typing.Any'

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

@@ -1,4 +0,0 @@
-from typing import TYPE_CHECKING
-
-assert TYPE_CHECKING == False, 'TYPE_CHECKING should be False'
-assert not TYPE_CHECKING, 'TYPE_CHECKING should be falsy'