superacli 1.1.5 → 1.1.7

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

@@ -1,353 +0,0 @@
-# === Basic nonlocal read/write ===
-def read_outer():
-    x = 10
-
-    def inner():
-        return x  # reads from outer scope
-
-    return inner()
-
-
-assert read_outer() == 10, 'nonlocal read'
-
-
-def write_outer():
-    x = 10
-
-    def inner():
-        nonlocal x
-        x = 20
-
-    inner()
-    return x
-
-
-assert write_outer() == 20, 'nonlocal write'
-
-
-# === Classic counter pattern ===
-def make_counter():
-    count = 0
-
-    def increment():
-        nonlocal count
-        count = count + 1
-        return count
-
-    return increment
-
-
-counter2 = make_counter()
-assert counter2() == 1, 'counter first call'
-assert counter2() == 2, 'counter second call'
-assert counter2() == 3, 'counter third call'
-
-
-# === Implicit capture (read without nonlocal) ===
-def implicit_capture():
-    a = 10
-    b = 20
-
-    def inner():
-        return a + b  # reads both from outer
-
-    return inner()
-
-
-assert implicit_capture() == 30, 'implicit capture multiple vars'
-
-
-# === Pass-through nesting ===
-def pass_through():
-    x = 1
-
-    def middle():
-        nonlocal x
-        x = x + 10
-
-        def inner():
-            nonlocal x
-            x = x + 100
-            return x
-
-        r1 = inner()  # returns 111
-        r2 = x  # x is now 111
-        return r1 + r2  # 222
-
-    return middle()
-
-
-assert pass_through() == 222, 'nonlocal pass through'
-
-
-# === Deep nesting (3 levels) ===
-def deep_nesting():
-    x = 1
-
-    def level2():
-        nonlocal x
-        x = x + 10
-
-        def level3():
-            nonlocal x
-            x = x + 100
-            return x
-
-        return level3()
-
-    return level2()
-
-
-assert deep_nesting() == 111, 'deep nesting'
-
-
-# === Deep nesting (4 levels) ===
-def deep_pass_through():
-    val = 1
-
-    def level1():
-        nonlocal val
-        val = val + 1
-
-        def level2():
-            nonlocal val
-            val = val + 10
-
-            def level3():
-                nonlocal val
-                val = val + 100
-                return val
-
-            return level3()
-
-        return level2()
-
-    result = level1()  # val: 1 -> 2 -> 12 -> 112
-    return (result, val)
-
-
-assert deep_pass_through() == (112, 112), 'deep pass through 4 levels'
-
-
-# === Multiple independent cells ===
-def multiple_cells():
-    a = 1
-    b = 10
-    c = 100
-
-    def modify_a():
-        nonlocal a
-        a = a + 1
-        return a
-
-    def modify_b():
-        nonlocal b
-        b = b + 10
-        return b
-
-    def modify_c():
-        nonlocal c
-        c = c + 100
-        return c
-
-    def read_all():
-        return a + b + c
-
-    r1 = modify_b()  # b = 20
-    r2 = modify_a()  # a = 2
-    r3 = modify_c()  # c = 200
-    r4 = read_all()  # 2 + 20 + 200 = 222
-    return (r1, r2, r3, r4)
-
-
-assert multiple_cells() == (20, 2, 200, 222), 'multiple independent cells'
-
-
-# === Shared cell (getter/setter pattern) ===
-def shared_cell():
-    x = 0
-
-    def getter():
-        return x
-
-    def setter(v):
-        nonlocal x
-        x = v
-
-    return (getter, setter)
-
-
-pair = shared_cell()
-getter = pair[0]
-setter = pair[1]
-assert getter() == 0, 'shared cell initial'
-setter(42)
-assert getter() == 42, 'shared cell after setter'
-
-
-# === Shared multiple vars ===
-def shared_multiple_vars():
-    x = 0
-    y = 0
-
-    def add_to_x(n):
-        nonlocal x
-        x = x + n
-        return x
-
-    def add_to_y(n):
-        nonlocal y
-        y = y + n
-        return y
-
-    def swap():
-        nonlocal x, y
-        tmp = x
-        x = y
-        y = tmp
-        return (x, y)
-
-    def get_both():
-        return (x, y)
-
-    return (add_to_x, add_to_y, swap, get_both)
-
-
-ops = shared_multiple_vars()
-add_x = ops[0]
-add_y = ops[1]
-swap = ops[2]
-get = ops[3]
-add_x(5)  # x=5
-add_y(10)  # y=10
-add_x(3)  # x=8
-swap()  # x=10, y=8
-assert get() == (10, 8), 'shared multiple vars with swap'
-
-
-# === Local and captured ===
-def local_and_captured():
-    x = 1
-
-    def inner():
-        nonlocal x
-        x = x + x
-        return x
-
-    before = x  # 1
-    middle = inner()  # 2
-    after = x  # 2
-    final = inner()  # 4
-    return (before, middle, after, final, x)
-
-
-assert local_and_captured() == (1, 2, 2, 4, 4), 'local and captured'
-
-
-# === Mixing global and nonlocal ===
-g1 = 100
-
-
-def global_and_nonlocal():
-    x = 1
-
-    def inner():
-        global g1
-        nonlocal x
-        g1 = g1 + 1
-        x = x + 10
-        return g1 + x
-
-    return inner()
-
-
-assert global_and_nonlocal() == 112, 'global and nonlocal together'
-
-
-# === Closure with global and nonlocal ===
-g2 = 1000
-
-
-def make_closure_global():
-    x = 1
-
-    def closure():
-        global g2
-        nonlocal x
-        result = g2 + x
-        g2 = g2 + 1
-        x = x + 10
-        return result
-
-    return closure
-
-
-c = make_closure_global()
-r1 = c()  # returns 1001
-r2 = c()  # returns 1012
-r3 = c()  # returns 1023
-assert (r1, r2, r3, g2) == (1001, 1012, 1023, 1003), 'closure with global and nonlocal'
-
-
-# === Closure creates closure ===
-def outer_factory():
-    outer_val = 10
-
-    def inner_factory():
-        nonlocal outer_val
-        inner_val = outer_val
-
-        def innermost():
-            nonlocal inner_val
-            inner_val = inner_val + 1
-            return inner_val
-
-        outer_val = outer_val + 100
-        return innermost
-
-    return inner_factory
-
-
-factory = outer_factory()
-closure1 = factory()  # inner_val=10, outer_val->110
-closure2 = factory()  # inner_val=110, outer_val->210
-r1 = closure1()  # 11
-r2 = closure1()  # 12
-r3 = closure2()  # 111
-r4 = closure1()  # 13
-assert (r1, r2, r3, r4) == (11, 12, 111, 13), 'closure creates closure'
-
-
-# === Augmented assignment with nonlocal ===
-def augmented_assign():
-    x = 10
-
-    def inner():
-        nonlocal x
-        x += 5
-
-    inner()
-    return x
-
-
-assert augmented_assign() == 15, 'augmented assign nonlocal'
-
-
-# === Cell contains closure ===
-def cell_contains_closure():
-    y = 100
-
-    def inner():
-        return y
-
-    x = inner  # x holds closure, x is also a cell var
-
-    def get_x():
-        nonlocal x
-        return x
-
-    f = get_x()
-    return f()
-
-
-assert cell_contains_closure() == 100, 'cell contains closure'

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

@@ -1,40 +0,0 @@
-# call-external
-# Tests for os.environ property
-
-import os
-
-# === os.environ property ===
-# os.environ returns a dict-like object
-env = os.environ
-
-# === os.environ key access ===
-assert env['VIRTUAL_HOME'] == '/virtual/home', 'environ key access VIRTUAL_HOME'
-assert os.environ['VIRTUAL_HOME'] == '/virtual/home', 'environ key access VIRTUAL_HOME'
-assert os.environ['VIRTUAL_USER'] == 'testuser', 'environ key access VIRTUAL_USER'
-assert os.environ['VIRTUAL_EMPTY'] == '', 'environ key access VIRTUAL_EMPTY'
-
-# === os.environ get method ===
-assert env.get('VIRTUAL_HOME') == '/virtual/home', 'environ.get existing key'
-assert os.environ.get('VIRTUAL_HOME') == '/virtual/home', 'environ.get existing key'
-assert os.environ.get('VIRTUAL_USER') == 'testuser', 'environ.get existing user'
-assert os.environ.get('NONEXISTENT_VAR_12345') is None, 'environ.get missing returns None'
-assert os.environ.get('NONEXISTENT_VAR_12345', 'default') == 'default', 'environ.get with default'
-
-# === os.environ length ===
-assert len(env) == 3, 'environ has 3 virtual entries'
-
-# === os.environ membership test ===
-assert 'VIRTUAL_HOME' in env, 'VIRTUAL_HOME in environ'
-assert 'VIRTUAL_HOME' in os.environ, 'VIRTUAL_HOME in environ'
-assert 'VIRTUAL_USER' in env, 'VIRTUAL_USER in environ'
-assert 'NONEXISTENT_VAR_12345' not in env, 'nonexistent not in environ'
-assert 'NONEXISTENT_VAR_12345' not in os.environ, 'nonexistent not in environ'
-
-# === os.environ keys/values/items ===
-keys = list(os.environ.keys())
-assert 'VIRTUAL_HOME' in keys, 'VIRTUAL_HOME in keys'
-assert 'VIRTUAL_USER' in keys, 'VIRTUAL_USER in keys'
-
-values = list(os.environ.values())
-assert '/virtual/home' in values, '/virtual/home in values'
-assert 'testuser' in values, 'testuser in values'

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

@@ -1,5 +0,0 @@
-# call-external
-import os
-
-os.getenv([1, 2, 3])
-# Raise=TypeError('str expected, not list')

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

@@ -1,5 +0,0 @@
-# call-external
-import os
-
-os.getenv(123)
-# Raise=TypeError('str expected, not int')

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

@@ -1,3 +0,0 @@
-# xfail=cpython
-1 + 2j
-# Raise=NotImplementedError('The monty syntax parser does not yet support complex constants')

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

@@ -1,11 +0,0 @@
-import pathlib
-
-# Verify that pathlib.Path can be called as an attribute
-p = pathlib.Path('a.txt')
-assert p.name == 'a.txt'
-
-# Verify that it still works when imported directly
-from pathlib import Path
-
-p2 = Path('b.txt')
-assert p2.name == 'b.txt'

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

@@ -1,136 +0,0 @@
-# call-external
-from pathlib import Path
-
-# === exists() ===
-assert Path('/virtual/file.txt').exists() == True, 'file exists'
-assert Path('/virtual/subdir').exists() == True, 'dir exists'
-assert Path('/virtual/subdir/deep').exists() == True, 'nested dir exists'
-assert Path('/nonexistent').exists() == False, 'nonexistent path'
-assert Path('/nonexistent/file.txt').exists() == False, 'nonexistent nested path'
-
-# === is_file() ===
-assert Path('/virtual/file.txt').is_file() == True, 'is_file true for file'
-assert Path('/virtual/subdir').is_file() == False, 'is_file false for dir'
-assert Path('/nonexistent').is_file() == False, 'is_file false for nonexistent'
-
-# === is_dir() ===
-assert Path('/virtual/subdir').is_dir() == True, 'is_dir true for dir'
-assert Path('/virtual/file.txt').is_dir() == False, 'is_dir false for file'
-assert Path('/nonexistent').is_dir() == False, 'is_dir false for nonexistent'
-
-# === is_symlink() ===
-assert Path('/virtual/file.txt').is_symlink() == False, 'is_symlink false (no symlinks in vfs)'
-assert Path('/nonexistent').is_symlink() == False, 'is_symlink false for nonexistent'
-
-# === read_text() ===
-assert Path('/virtual/file.txt').read_text() == 'hello world\n', 'read_text basic'
-assert Path('/virtual/empty.txt').read_text() == '', 'read_text empty file'
-assert Path('/virtual/subdir/nested.txt').read_text() == 'nested content', 'read_text nested'
-assert Path('/virtual/subdir/deep/file.txt').read_text() == 'deep', 'read_text deep nested'
-
-# === read_bytes() ===
-assert Path('/virtual/data.bin').read_bytes() == b'\x00\x01\x02\x03', 'read_bytes binary'
-assert Path('/virtual/empty.txt').read_bytes() == b'', 'read_bytes empty'
-assert Path('/virtual/file.txt').read_bytes() == b'hello world\n', 'read_bytes text file'
-
-# === stat() basic ===
-st = Path('/virtual/file.txt').stat()
-assert st.st_size == 12, 'stat size (len of "hello world\\n")'
-# 0o644 permissions + regular file type bits (0o100000)
-assert st.st_mode & 0o777 == 0o644, 'stat mode permissions'
-# Verify it's a regular file using raw mode bits
-# S_IFREG = 0o100000, so check that file type bits match
-assert st.st_mode & 0o170000 == 0o100000, 'stat is regular file'
-
-# === stat() directory ===
-st_dir = Path('/virtual/subdir').stat()
-# S_IFDIR = 0o040000, so check that file type bits match
-assert st_dir.st_mode & 0o170000 == 0o040000, 'stat is directory'
-assert st_dir.st_mode & 0o777 == 0o755, 'stat dir mode permissions'
-
-# === stat() index access ===
-st2 = Path('/virtual/file.txt').stat()
-assert st2[6] == 12, 'stat index access for st_size'
-assert st2[0] & 0o777 == 0o644, 'stat index access for st_mode'
-
-# === iterdir() ===
-entries = list(Path('/virtual').iterdir())
-assert len(entries) == 5, 'iterdir returns correct count'
-
-# iterdir() should return Path objects, not strings
-first_entry = entries[0]
-assert isinstance(first_entry, Path), f'iterdir should return Path objects, got {type(first_entry)}'
-
-# Path objects should have .name attribute
-names = [e.name for e in entries]
-assert 'file.txt' in names, 'iterdir contains file.txt'
-assert 'subdir' in names, 'iterdir contains subdir'
-assert 'data.bin' in names, 'iterdir contains data.bin'
-
-# Path objects should have .parent attribute
-assert entries[0].parent == Path('/virtual'), 'iterdir entry parent is correct'
-
-# === iterdir() nested ===
-nested_entries = list(Path('/virtual/subdir').iterdir())
-assert len(nested_entries) == 2, 'iterdir nested count'
-nested_names = [e.name for e in nested_entries]
-assert 'nested.txt' in nested_names, 'iterdir nested contains nested.txt'
-assert 'deep' in nested_names, 'iterdir nested contains deep'
-
-# === iterdir() entries can be used for further operations ===
-# Find the nested.txt entry and read it
-for entry in nested_entries:
-    if entry.name == 'nested.txt':
-        assert entry.read_text() == 'nested content', 'iterdir entry can be read'
-
-# === resolve() ===
-p = Path('/virtual/file.txt').resolve()
-assert str(p) == '/virtual/file.txt', 'resolve absolute path unchanged'
-
-# === absolute() ===
-p2 = Path('/virtual/subdir').absolute()
-assert str(p2) == '/virtual/subdir', 'absolute path unchanged'
-
-# === path concatenation with OS calls ===
-base = Path('/virtual')
-full = base / 'subdir' / 'nested.txt'
-assert full.read_text() == 'nested content', 'path concat then read'
-assert full.exists() == True, 'path concat then exists'
-
-# === write_text() ===
-Path('/virtual/new_file.txt').write_text('created by write_text')
-assert Path('/virtual/new_file.txt').read_text() == 'created by write_text', 'write_text creates file'
-# Overwrite existing file
-Path('/virtual/file.txt').write_text('overwritten')
-assert Path('/virtual/file.txt').read_text() == 'overwritten', 'write_text overwrites'
-
-# === write_bytes() ===
-Path('/virtual/binary.dat').write_bytes(b'\xff\xfe\xfd')
-assert Path('/virtual/binary.dat').read_bytes() == b'\xff\xfe\xfd', 'write_bytes creates file'
-
-# === mkdir() ===
-Path('/virtual/new_dir').mkdir()
-assert Path('/virtual/new_dir').is_dir() == True, 'mkdir creates directory'
-# mkdir with parents
-Path('/virtual/a/b/c').mkdir(parents=True)
-assert Path('/virtual/a/b/c').is_dir() == True, 'mkdir parents creates nested'
-# mkdir with exist_ok
-Path('/virtual/new_dir').mkdir(exist_ok=True)  # Should not raise
-
-# === unlink() ===
-Path('/virtual/to_delete.txt').write_text('delete me')
-assert Path('/virtual/to_delete.txt').exists() == True, 'file exists before unlink'
-Path('/virtual/to_delete.txt').unlink()
-assert Path('/virtual/to_delete.txt').exists() == False, 'unlink removes file'
-
-# === rmdir() ===
-Path('/virtual/empty_dir').mkdir()
-assert Path('/virtual/empty_dir').is_dir() == True, 'dir exists before rmdir'
-Path('/virtual/empty_dir').rmdir()
-assert Path('/virtual/empty_dir').exists() == False, 'rmdir removes directory'
-
-# === rename() ===
-Path('/virtual/old_name.txt').write_text('rename test')
-Path('/virtual/old_name.txt').rename(Path('/virtual/new_name.txt'))
-assert Path('/virtual/old_name.txt').exists() == False, 'rename removes old path'
-assert Path('/virtual/new_name.txt').read_text() == 'rename test', 'rename creates new path'

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

@@ -1,12 +0,0 @@
-# call-external
-from pathlib import Path
-
-Path('/nonexistent').read_text()
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "pathlib__os_read_error.py", line 4, in <module>
-    Path('/nonexistent').read_text()
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent'
-"""

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

@@ -1,81 +0,0 @@
-# === Path constructor ===
-from pathlib import Path
-
-p = Path('/usr/local/bin/python')
-assert str(p) == '/usr/local/bin/python', 'Path str should match input'
-
-# Constructor with multiple arguments
-assert str(Path('folder', 'file.txt')) == 'folder/file.txt', 'Path with two args joins'
-assert str(Path('/usr', 'local', 'bin')) == '/usr/local/bin', 'Path with three args joins'
-assert str(Path('start', '/absolute', 'end')) == '/absolute/end', 'absolute in middle replaces'
-
-# Constructor with no arguments
-assert str(Path()) == '.', 'Path() returns current dir'
-
-# === name property ===
-assert p.name == 'python', 'name should be final component'
-assert Path('/usr/local/bin/').name == 'bin', 'name should handle trailing slash'
-assert Path('/').name == '', 'root path should have empty name'
-assert Path('file.txt').name == 'file.txt', 'relative path name'
-
-# === parent property ===
-assert str(p.parent) == '/usr/local/bin', 'parent should remove last component'
-assert str(Path('/usr').parent) == '/', 'parent of first-level should be root'
-assert str(Path('/').parent) == '/', 'parent of root is root'
-assert str(Path('file.txt').parent) == '.', 'parent of relative without dir is .'
-
-# === stem property ===
-assert Path('/path/file.tar.gz').stem == 'file.tar', 'stem removes last extension'
-assert Path('/path/file.txt').stem == 'file', 'stem removes single extension'
-assert Path('/path/.bashrc').stem == '.bashrc', 'stem preserves hidden files'
-assert Path('/path/file').stem == 'file', 'stem without extension'
-
-# === suffix property ===
-assert Path('/path/file.tar.gz').suffix == '.gz', 'suffix is last extension'
-assert Path('/path/file.txt').suffix == '.txt', 'suffix with single extension'
-assert Path('/path/.bashrc').suffix == '', 'hidden file has no suffix'
-assert Path('/path/file').suffix == '', 'no extension means empty suffix'
-
-# === suffixes property ===
-assert Path('/path/file.tar.gz').suffixes == ['.tar', '.gz'], 'suffixes list'
-assert Path('/path/file.txt').suffixes == ['.txt'], 'single suffix as list'
-assert Path('/path/.bashrc').suffixes == [], 'hidden file has no suffixes'
-
-# === parts property ===
-assert Path('/usr/local/bin').parts == ('/', 'usr', 'local', 'bin'), 'absolute path parts'
-assert Path('usr/local').parts == ('usr', 'local'), 'relative path parts'
-assert Path('/').parts == ('/',), 'root path parts'
-
-# === is_absolute method ===
-assert Path('/usr/bin').is_absolute() == True, 'absolute path'
-assert Path('usr/bin').is_absolute() == False, 'relative path not absolute'
-assert Path('').is_absolute() == False, 'empty path not absolute'
-
-# === joinpath method ===
-assert str(Path('/usr').joinpath('local')) == '/usr/local', 'joinpath with one arg'
-assert str(Path('/usr').joinpath('local', 'bin')) == '/usr/local/bin', 'joinpath with two args'
-assert str(Path('/usr').joinpath('/etc')) == '/etc', 'joinpath with absolute replaces'
-assert str(Path('.').joinpath('file')) == 'file', 'joinpath from dot'
-
-# === with_name method ===
-assert str(Path('/path/file.txt').with_name('other.py')) == '/path/other.py', 'with_name replaces name'
-assert str(Path('file.txt').with_name('other.py')) == 'other.py', 'with_name on relative'
-
-# === with_suffix method ===
-assert str(Path('/path/file.txt').with_suffix('.py')) == '/path/file.py', 'with_suffix replaces'
-assert str(Path('/path/file.txt').with_suffix('')) == '/path/file', 'with_suffix removes'
-assert str(Path('/path/file').with_suffix('.txt')) == '/path/file.txt', 'with_suffix adds'
-
-# === / operator ===
-assert str(Path('/usr') / 'local') == '/usr/local', '/ operator joins'
-assert str(Path('/usr') / 'local' / 'bin') == '/usr/local/bin', '/ operator chains'
-
-# === as_posix method ===
-assert Path('/usr/bin').as_posix() == '/usr/bin', 'as_posix returns string'
-
-# === __fspath__ method (os.PathLike protocol) ===
-assert Path('/usr/bin').__fspath__() == '/usr/bin', '__fspath__ returns string'
-
-# === repr ===
-r = repr(Path('/usr/bin'))
-assert r == "PosixPath('/usr/bin')", f'repr should be PosixPath, got {r}'

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

@@ -1,5 +0,0 @@
-# Test that returning a cyclic dict doesn't crash (MontyObject cycle detection)
-d = {}
-d['self'] = d
-d
-# Return={'self': {...}}

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

@@ -1,6 +0,0 @@
-# Test composite cycle: list containing dict containing original list
-c = []
-e = {'list': c}
-c.append(e)
-c
-# Return=[{'list': [...]}]

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

@@ -1,5 +0,0 @@
-# Test that returning a cyclic list doesn't crash (MontyObject cycle detection)
-a = []
-a.append(a)
-a
-# Return=[[...]]

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

@@ -1,6 +0,0 @@
-# Test multiple references to the same cyclic object
-f = []
-f.append(f)
-g = [f, f]
-g
-# Return=[[[...]], [[...]]]

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

@@ -1,2 +0,0 @@
-range()
-# Raise=TypeError('range expected at least 1 argument, got 0')