superacli 1.1.4 → 1.1.6

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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